pub enum Expr {
Show 31 variants
Alias(Box<Expr, Global>, Arc<str>),
Column(Arc<str>),
Columns(Vec<String, Global>),
DtypeColumn(Vec<DataType, Global>),
Literal(LiteralValue),
BinaryExpr {
left: Box<Expr, Global>,
op: Operator,
right: Box<Expr, Global>,
},
Not(Box<Expr, Global>),
IsNotNull(Box<Expr, Global>),
IsNull(Box<Expr, Global>),
Cast {
expr: Box<Expr, Global>,
data_type: DataType,
strict: bool,
},
Sort {
expr: Box<Expr, Global>,
options: SortOptions,
},
Take {
expr: Box<Expr, Global>,
idx: Box<Expr, Global>,
},
SortBy {
expr: Box<Expr, Global>,
by: Vec<Expr, Global>,
reverse: Vec<bool, Global>,
},
Agg(AggExpr),
Ternary {
predicate: Box<Expr, Global>,
truthy: Box<Expr, Global>,
falsy: Box<Expr, Global>,
},
AnonymousFunction {
input: Vec<Expr, Global>,
function: SpecialEq<Arc<dyn SeriesUdf + 'static>>,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>,
options: FunctionOptions,
},
Function {
input: Vec<Expr, Global>,
function: FunctionExpr,
options: FunctionOptions,
},
Shift {
input: Box<Expr, Global>,
periods: i64,
},
Reverse(Box<Expr, Global>),
Duplicated(Box<Expr, Global>),
IsUnique(Box<Expr, Global>),
Explode(Box<Expr, Global>),
Filter {
input: Box<Expr, Global>,
by: Box<Expr, Global>,
},
Window {
function: Box<Expr, Global>,
partition_by: Vec<Expr, Global>,
order_by: Option<Box<Expr, Global>>,
options: WindowOptions,
},
Wildcard,
Slice {
input: Box<Expr, Global>,
offset: Box<Expr, Global>,
length: Box<Expr, Global>,
},
Exclude(Box<Expr, Global>, Vec<Excluded, Global>),
KeepName(Box<Expr, Global>),
RenameAlias {
function: SpecialEq<Arc<dyn RenameAliasFn + 'static>>,
expr: Box<Expr, Global>,
},
Count,
Nth(i64),
}
Expand description
Queries consists of multiple ex pressions.
Variants
Alias(Box<Expr, Global>, Arc<str>)
Column(Arc<str>)
Columns(Vec<String, Global>)
DtypeColumn(Vec<DataType, Global>)
Literal(LiteralValue)
BinaryExpr
Not(Box<Expr, Global>)
IsNotNull(Box<Expr, Global>)
IsNull(Box<Expr, Global>)
Cast
Sort
Take
SortBy
Agg(AggExpr)
Ternary
A ternary operation if true then “foo” else “bar”
AnonymousFunction
Fields
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
output dtype of the function
options: FunctionOptions
Function
Fields
options: FunctionOptions
Shift
Reverse(Box<Expr, Global>)
Duplicated(Box<Expr, Global>)
IsUnique(Box<Expr, Global>)
Explode(Box<Expr, Global>)
Filter
Window
Fields
options: WindowOptions
See postgres window functions
Wildcard
Slice
Fields
Exclude(Box<Expr, Global>, Vec<Excluded, Global>)
Can be used in a select statement to exclude a column from selection
KeepName(Box<Expr, Global>)
Set root name as Alias
RenameAlias
Count
Special case that does not need columns
Nth(i64)
Take the nth column in the DataFrame
Implementations
sourceimpl Expr
impl Expr
sourcepub fn to_dot(&self) -> Result<String, PolarsError>
pub fn to_dot(&self) -> Result<String, PolarsError>
Get a dot language representation of the Expression.
sourceimpl Expr
impl Expr
sourcepub fn eq<E>(self, other: E) -> Expr where
E: Into<Expr>,
pub fn eq<E>(self, other: E) -> Expr where
E: Into<Expr>,
Compare Expr
with other Expr
on equality
sourcepub fn neq<E>(self, other: E) -> Expr where
E: Into<Expr>,
pub fn neq<E>(self, other: E) -> Expr where
E: Into<Expr>,
Compare Expr
with other Expr
on non-equality
sourcepub fn is_not_null(self) -> Expr
pub fn is_not_null(self) -> Expr
Run is_not_null operation on Expr
.
sourcepub fn drop_nulls(self) -> Expr
pub fn drop_nulls(self) -> Expr
Drop null values
sourcepub fn quantile(self, quantile: f64, interpol: QuantileInterpolOptions) -> Expr
pub fn quantile(self, quantile: f64, interpol: QuantileInterpolOptions) -> Expr
Compute the quantile per group.
sourcepub fn agg_groups(self) -> Expr
pub fn agg_groups(self) -> Expr
Get the group indexes of the group by operation.
sourcepub fn slice<E, F>(self, offset: E, length: F) -> Expr where
E: Into<Expr>,
F: Into<Expr>,
pub fn slice<E, F>(self, offset: E, length: F) -> Expr where
E: Into<Expr>,
F: Into<Expr>,
Slice the Series.
offset
may be negative.
sourcepub fn append<E>(self, other: E, upcast: bool) -> Expr where
E: Into<Expr>,
pub fn append<E>(self, other: E, upcast: bool) -> Expr where
E: Into<Expr>,
Append expressions. This is done by adding the chunks of other
to this Series
.
sourcepub fn unique_stable(self) -> Expr
pub fn unique_stable(self) -> Expr
Get unique values of this expression, while maintaining order.
This requires more work than Expr::unique
.
sourcepub fn arg_unique(self) -> Expr
pub fn arg_unique(self) -> Expr
Get the first index of unique values of this expression.
sourcepub fn arg_sort(self, reverse: bool) -> Expr
pub fn arg_sort(self, reverse: bool) -> Expr
Get the index values that would sort this expression.
sourcepub fn strict_cast(self, data_type: DataType) -> Expr
pub fn strict_cast(self, data_type: DataType) -> Expr
Cast expression to another data type. Throws an error if conversion had overflows
sourcepub fn sort(self, reverse: bool) -> Expr
pub fn sort(self, reverse: bool) -> Expr
Sort in increasing order. See the eager implementation.
sourcepub fn sort_with(self, options: SortOptions) -> Expr
pub fn sort_with(self, options: SortOptions) -> Expr
Sort with given options.
sourcepub fn map<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
pub fn map<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
Apply a function/closure once the logical plan get executed.
This function is very similar to Expr::apply
, but differs in how it handles aggregations.
map
should be used for operations that are independent of groups, e.g.multiply * 2
, orraise to the power
apply
should be used for operations that work on a group of data. e.g.sum
,count
, etc.
It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.
sourcepub fn map_many<F>(
self,
function: F,
arguments: &[Expr],
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(&mut [Series]) -> Result<Series, PolarsError> + Send + Sync,
pub fn map_many<F>(
self,
function: F,
arguments: &[Expr],
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(&mut [Series]) -> Result<Series, PolarsError> + Send + Sync,
sourcepub fn map_list<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
pub fn map_list<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
Apply a function/closure once the logical plan get executed.
This function is very similar to apply, but differs in how it handles aggregations.
map
should be used for operations that are independent of groups, e.g.multiply * 2
, orraise to the power
apply
should be used for operations that work on a group of data. e.g.sum
,count
, etc.map_list
should be used when the function expects a list aggregated series.
sourcepub fn function_with_options<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>,
options: FunctionOptions
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
pub fn function_with_options<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>,
options: FunctionOptions
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
A function that cannot be expressed with map
or apply
and requires extra settings.
sourcepub fn apply<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
pub fn apply<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(Series) -> Result<Series, PolarsError> + Send + Sync,
Apply a function/closure over the groups. This should only be used in a groupby aggregation.
It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.
This difference with map is that apply
will create a separate Series
per group.
map
should be used for operations that are independent of groups, e.g.multiply * 2
, orraise to the power
apply
should be used for operations that work on a group of data. e.g.sum
,count
, etc.
sourcepub fn apply_many<F>(
self,
function: F,
arguments: &[Expr],
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(&mut [Series]) -> Result<Series, PolarsError> + Send + Sync,
pub fn apply_many<F>(
self,
function: F,
arguments: &[Expr],
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>
) -> Expr where
F: 'static + Fn(&mut [Series]) -> Result<Series, PolarsError> + Send + Sync,
Apply a function/closure over the groups with many arguments. This should only be used in a groupby aggregation.
See the Expr::apply
function for the differences between map
and apply
.
pub fn apply_many_private(
self,
function_expr: FunctionExpr,
arguments: &[Expr],
fmt_str: &'static str
) -> Expr
pub fn map_many_private(
self,
function_expr: FunctionExpr,
arguments: &[Expr],
fmt_str: &'static str
) -> Expr
sourcepub fn is_infinite(self) -> Expr
pub fn is_infinite(self) -> Expr
Get mask of infinite values if dtype is Float
sourcepub fn is_not_nan(self) -> Expr
pub fn is_not_nan(self) -> Expr
Get inverse mask of NaN values if dtype is Float
sourcepub fn shift(self, periods: i64) -> Expr
pub fn shift(self, periods: i64) -> Expr
Shift the values in the array by some period. See the eager implementation.
sourcepub fn shift_and_fill<E>(self, periods: i64, fill_value: E) -> Expr where
E: Into<Expr>,
pub fn shift_and_fill<E>(self, periods: i64, fill_value: E) -> Expr where
E: Into<Expr>,
Shift the values in the array by some period and fill the resulting empty values.
sourcepub fn cumsum(self, reverse: bool) -> Expr
pub fn cumsum(self, reverse: bool) -> Expr
Get an array with the cumulative sum computed at every element
sourcepub fn cumprod(self, reverse: bool) -> Expr
pub fn cumprod(self, reverse: bool) -> Expr
Get an array with the cumulative product computed at every element
sourcepub fn cummin(self, reverse: bool) -> Expr
pub fn cummin(self, reverse: bool) -> Expr
Get an array with the cumulative min computed at every element
sourcepub fn cummax(self, reverse: bool) -> Expr
pub fn cummax(self, reverse: bool) -> Expr
Get an array with the cumulative max computed at every element
sourcepub fn backward_fill(self, limit: Option<u32>) -> Expr
pub fn backward_fill(self, limit: Option<u32>) -> Expr
Fill missing value with next non-null.
sourcepub fn forward_fill(self, limit: Option<u32>) -> Expr
pub fn forward_fill(self, limit: Option<u32>) -> Expr
Fill missing value with previous non-null.
sourcepub fn round(self, decimals: u32) -> Expr
pub fn round(self, decimals: u32) -> Expr
Round underlying floating point array to given decimal numbers.
sourcepub fn floor(self) -> Expr
pub fn floor(self) -> Expr
Floor underlying floating point array to the lowest integers smaller or equal to the float value.
sourcepub fn ceil(self) -> Expr
pub fn ceil(self) -> Expr
Ceil underlying floating point array to the highest integers smaller or equal to the float value.
sourcepub fn over<E, IE>(self, partition_by: E) -> Expr where
E: AsRef<[IE]>,
IE: Into<Expr> + Clone,
pub fn over<E, IE>(self, partition_by: E) -> Expr where
E: AsRef<[IE]>,
IE: Into<Expr> + Clone,
Apply window function over a subgroup. This is similar to a groupby + aggregation + self join. Or similar to window functions in Postgres.
Example
#[macro_use] extern crate polars_core;
use polars_core::prelude::*;
use polars_lazy::prelude::*;
fn example() -> Result<()> {
let df = df! {
"groups" => &[1, 1, 2, 2, 1, 2, 3, 3, 1],
"values" => &[1, 2, 3, 4, 5, 6, 7, 8, 8]
}?;
let out = df
.lazy()
.select(&[
col("groups"),
sum("values").over([col("groups")]),
])
.collect()?;
dbg!(&out);
Ok(())
}
Outputs:
╭────────┬────────╮
│ groups ┆ values │
│ --- ┆ --- │
│ i32 ┆ i32 │
╞════════╪════════╡
│ 1 ┆ 16 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 16 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2 ┆ 13 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2 ┆ 13 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ ... ┆ ... │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 16 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2 ┆ 13 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3 ┆ 15 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3 ┆ 15 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 16 │
╰────────┴────────╯
sourcepub fn fill_null<E>(self, fill_value: E) -> Expr where
E: Into<Expr>,
pub fn fill_null<E>(self, fill_value: E) -> Expr where
E: Into<Expr>,
Replace the null values by a value.
sourcepub fn fill_nan<E>(self, fill_value: E) -> Expr where
E: Into<Expr>,
pub fn fill_nan<E>(self, fill_value: E) -> Expr where
E: Into<Expr>,
Replace the floating point NaN
values by a value.
sourcepub fn count(self) -> Expr
pub fn count(self) -> Expr
Count the values of the Series or Get counts of the group by operation.
sourcepub fn is_duplicated(self) -> Expr
pub fn is_duplicated(self) -> Expr
Get a mask of duplicated values
pub fn xor<E>(self, expr: E) -> Expr where
E: Into<Expr>,
sourcepub fn pow<E>(self, exponent: E) -> Expr where
E: Into<Expr>,
pub fn pow<E>(self, exponent: E) -> Expr where
E: Into<Expr>,
Raise expression to the power exponent
sourcepub fn filter<E>(self, predicate: E) -> Expr where
E: Into<Expr>,
pub fn filter<E>(self, predicate: E) -> Expr where
E: Into<Expr>,
Filter a single column Should be used in aggregation context. If you want to filter on a DataFrame level, use LazyFrame::filter
sourcepub fn is_in<E>(self, other: E) -> Expr where
E: Into<Expr>,
pub fn is_in<E>(self, other: E) -> Expr where
E: Into<Expr>,
Check if the values of the left expression are in the lists of the right expr.
sourcepub fn sort_by<E, IE, R>(self, by: E, reverse: R) -> Expr where
E: AsRef<[IE]>,
IE: Into<Expr> + Clone,
R: AsRef<[bool]>,
pub fn sort_by<E, IE, R>(self, by: E, reverse: R) -> Expr where
E: AsRef<[IE]>,
IE: Into<Expr> + Clone,
R: AsRef<[bool]>,
Sort this column by the ordering of another column. Can also be used in a groupby context to sort the groups.
sourcepub fn repeat_by<E>(self, by: E) -> Expr where
E: Into<Expr>,
pub fn repeat_by<E>(self, by: E) -> Expr where
E: Into<Expr>,
Repeat the column n
times, where n
is determined by the values in by
.
This yields an Expr
of dtype List
sourcepub fn mode(self) -> Expr
pub fn mode(self) -> Expr
Compute the mode(s) of this column. This is the most occurring value.
sourcepub fn keep_name(self) -> Expr
pub fn keep_name(self) -> Expr
Keep the original root name
use polars_core::prelude::*;
use polars_lazy::prelude::*;
fn example(df: LazyFrame) -> LazyFrame {
df.select([
// even thought the alias yields a different column name,
// `keep_name` will make sure that the original column name is used
col("*").alias("foo").keep_name()
])
}
sourcepub fn map_alias<F>(self, function: F) -> Expr where
F: 'static + Fn(&str) -> String + Send + Sync,
pub fn map_alias<F>(self, function: F) -> Expr where
F: 'static + Fn(&str) -> String + Send + Sync,
Define an alias by mapping a function over the original root column name.
sourcepub fn exclude(self, columns: impl IntoVec<String>) -> Expr
pub fn exclude(self, columns: impl IntoVec<String>) -> Expr
Exclude a column from a wildcard/regex selection.
You may also use regexes in the exclude as long as they start with ^
and end with $
/
Example
use polars_core::prelude::*;
use polars_lazy::prelude::*;
// Select all columns except foo.
fn example(df: DataFrame) -> LazyFrame {
df.lazy()
.select(&[
col("*").exclude(&["foo"])
])
}
pub fn exclude_dtype<D>(self, dtypes: D) -> Expr where
D: AsRef<[DataType]>,
pub fn interpolate(self) -> Expr
sourcepub fn rolling_min(self, options: RollingOptions) -> Expr
pub fn rolling_min(self, options: RollingOptions) -> Expr
Apply a rolling min See: [ChunkedArray::rolling_min]
sourcepub fn rolling_max(self, options: RollingOptions) -> Expr
pub fn rolling_max(self, options: RollingOptions) -> Expr
Apply a rolling max See: [ChunkedArray::rolling_max]
sourcepub fn rolling_mean(self, options: RollingOptions) -> Expr
pub fn rolling_mean(self, options: RollingOptions) -> Expr
Apply a rolling mean See: [ChunkedArray::rolling_mean]
sourcepub fn rolling_sum(self, options: RollingOptions) -> Expr
pub fn rolling_sum(self, options: RollingOptions) -> Expr
Apply a rolling sum See: [ChunkedArray::rolling_sum]
sourcepub fn rolling_median(self, options: RollingOptions) -> Expr
pub fn rolling_median(self, options: RollingOptions) -> Expr
Apply a rolling median See:
[ChunkedArray::rolling_median
]
sourcepub fn rolling_quantile(
self,
quantile: f64,
interpolation: QuantileInterpolOptions,
options: RollingOptions
) -> Expr
pub fn rolling_quantile(
self,
quantile: f64,
interpolation: QuantileInterpolOptions,
options: RollingOptions
) -> Expr
Apply a rolling quantile See:
[ChunkedArray::rolling_quantile
]
sourcepub fn rolling_var(self, options: RollingOptions) -> Expr
pub fn rolling_var(self, options: RollingOptions) -> Expr
Apply a rolling variance
sourcepub fn rolling_std(self, options: RollingOptions) -> Expr
pub fn rolling_std(self, options: RollingOptions) -> Expr
Apply a rolling std-dev
sourcepub fn rolling_apply(
self,
f: Arc<dyn Fn(&Series) + Send + Sync + 'static>,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>,
options: RollingOptionsFixedWindow
) -> Expr
pub fn rolling_apply(
self,
f: Arc<dyn Fn(&Series) + Send + Sync + 'static>,
output_type: SpecialEq<Arc<dyn FunctionOutputField + 'static>>,
options: RollingOptionsFixedWindow
) -> Expr
Apply a custom function over a rolling/ moving window of the array. This has quite some dynamic dispatch, so prefer rolling_min, max, mean, sum over this.
sourcepub fn rolling_apply_float<F>(self, window_size: usize, f: F) -> Expr where
F: 'static + FnMut(&mut ChunkedArray<Float64Type>) -> Option<f64> + Send + Sync + Copy,
pub fn rolling_apply_float<F>(self, window_size: usize, f: F) -> Expr where
F: 'static + FnMut(&mut ChunkedArray<Float64Type>) -> Option<f64> + Send + Sync + Copy,
Apply a custom function over a rolling/ moving window of the array. Prefer this over rolling_apply in case of floating point numbers as this is faster. This has quite some dynamic dispatch, so prefer rolling_min, max, mean, sum over this.
pub fn rank(self, options: RankOptions) -> Expr
pub fn diff(self, n: usize, null_behavior: NullBehavior) -> Expr
sourcepub fn upper_bound(self) -> Expr
pub fn upper_bound(self) -> Expr
Get maximal value that could be hold by this dtype.
sourcepub fn lower_bound(self) -> Expr
pub fn lower_bound(self) -> Expr
Get minimal value that could be hold by this dtype.
pub fn reshape(self, dims: &[i64]) -> Expr
pub fn shuffle(self, seed: u64) -> Expr
pub fn sample_frac(
self,
frac: f64,
with_replacement: bool,
shuffle: bool,
seed: Option<u64>
) -> Expr
sourcepub fn to_float(self) -> Expr
pub fn to_float(self) -> Expr
This is useful if an apply
function needs a floating point type.
Because this cast is done on a map
level, it will be faster.
sourcepub fn value_counts(self, multithreaded: bool, sorted: bool) -> Expr
pub fn value_counts(self, multithreaded: bool, sorted: bool) -> Expr
Count all unique values and create a struct mapping value to count Note that it is better to turn multithreaded off in the aggregation context
sourcepub fn null_count(self) -> Expr
pub fn null_count(self) -> Expr
Get the null count of the column/group
sourcepub fn set_sorted(self, sorted: IsSorted) -> Expr
pub fn set_sorted(self, sorted: IsSorted) -> Expr
Set this Series
as sorted
so that downstream code can use
fast paths for sorted arrays.
Warning
This can lead to incorrect results if this Series
is not sorted!!
Use with care!
pub fn str(self) -> StringNameSpace
pub fn dt(self) -> DateLikeNameSpace
pub fn arr(self) -> ListNameSpace
pub fn cat(self) -> CategoricalNameSpace
pub fn struct_(self) -> StructNameSpace
Trait Implementations
sourceimpl<'a> IntoIterator for &'a Expr
impl<'a> IntoIterator for &'a Expr
impl Eq for Expr
impl StructuralPartialEq for Expr
Auto Trait Implementations
impl !RefUnwindSafe for Expr
impl Send for Expr
impl Sync for Expr
impl Unpin for Expr
impl !UnwindSafe for Expr
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> CallHasher for T where
T: Hash + ?Sized,
impl<T> CallHasher for T where
T: Hash + ?Sized,
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.