Struct otter_api_tests::crates::otter_support::crates::otter_base::crates::itertools::structs::GroupingMap
source · [−]pub struct GroupingMap<I> { /* private fields */ }
Expand description
GroupingMap
is an intermediate struct for efficient group-and-fold operations.
It groups elements by their key and at the same time fold each group
using some aggregating operation.
No method on this struct performs temporary allocations.
Implementations
sourceimpl<I, K, V> GroupingMap<I> where
I: Iterator<Item = (K, V)>,
K: Hash + Eq,
impl<I, K, V> GroupingMap<I> where
I: Iterator<Item = (K, V)>,
K: Hash + Eq,
sourcepub fn aggregate<FO, R>(self, operation: FO) -> HashMap<K, R, RandomState> where
FO: for<'_> FnMut(Option<R>, &K, V) -> Option<R>,
pub fn aggregate<FO, R>(self, operation: FO) -> HashMap<K, R, RandomState> where
FO: for<'_> FnMut(Option<R>, &K, V) -> Option<R>,
This is the generic way to perform any operation on a GroupingMap
.
It’s suggested to use this method only to implement custom operations
when the already provided ones are not enough.
Groups elements from the GroupingMap
source by key and applies operation
to the elements
of each group sequentially, passing the previously accumulated value, a reference to the key
and the current element as arguments, and stores the results in an HashMap
.
The operation
function is invoked on each element with the following parameters:
- the current value of the accumulator of the group if there is currently one;
- a reference to the key of the group this element belongs to;
- the element from the source being aggregated;
If operation
returns Some(element)
then the accumulator is updated with element
,
otherwise the previous accumulation is discarded.
Return a HashMap
associating the key of each group with the result of aggregation of
that group’s elements. If the aggregation of the last element of a group discards the
accumulator then there won’t be an entry associated to that group’s key.
use itertools::Itertools;
let data = vec![2, 8, 5, 7, 9, 0, 4, 10];
let lookup = data.into_iter()
.into_grouping_map_by(|&n| n % 4)
.aggregate(|acc, _key, val| {
if val == 0 || val == 10 {
None
} else {
Some(acc.unwrap_or(0) + val)
}
});
assert_eq!(lookup[&0], 4); // 0 resets the accumulator so only 4 is summed
assert_eq!(lookup[&1], 5 + 9);
assert_eq!(lookup.get(&2), None); // 10 resets the accumulator and nothing is summed afterward
assert_eq!(lookup[&3], 7);
assert_eq!(lookup.len(), 3); // The final keys are only 0, 1 and 2
sourcepub fn fold<FO, R>(self, init: R, operation: FO) -> HashMap<K, R, RandomState> where
R: Clone,
FO: for<'_> FnMut(R, &K, V) -> R,
pub fn fold<FO, R>(self, init: R, operation: FO) -> HashMap<K, R, RandomState> where
R: Clone,
FO: for<'_> FnMut(R, &K, V) -> R,
Groups elements from the GroupingMap
source by key and applies operation
to the elements
of each group sequentially, passing the previously accumulated value, a reference to the key
and the current element as arguments, and stores the results in a new map.
init
is the value from which will be cloned the initial value of each accumulator.
operation
is a function that is invoked on each element with the following parameters:
- the current value of the accumulator of the group;
- a reference to the key of the group this element belongs to;
- the element from the source being accumulated.
Return a HashMap
associating the key of each group with the result of folding that group’s elements.
use itertools::Itertools;
let lookup = (1..=7)
.into_grouping_map_by(|&n| n % 3)
.fold(0, |acc, _key, val| acc + val);
assert_eq!(lookup[&0], 3 + 6);
assert_eq!(lookup[&1], 1 + 4 + 7);
assert_eq!(lookup[&2], 2 + 5);
assert_eq!(lookup.len(), 3);
sourcepub fn fold_first<FO>(self, operation: FO) -> HashMap<K, V, RandomState> where
FO: for<'_> FnMut(V, &K, V) -> V,
pub fn fold_first<FO>(self, operation: FO) -> HashMap<K, V, RandomState> where
FO: for<'_> FnMut(V, &K, V) -> V,
Groups elements from the GroupingMap
source by key and applies operation
to the elements
of each group sequentially, passing the previously accumulated value, a reference to the key
and the current element as arguments, and stores the results in a new map.
This is similar to fold
but the initial value of the accumulator is the first element of the group.
operation
is a function that is invoked on each element with the following parameters:
- the current value of the accumulator of the group;
- a reference to the key of the group this element belongs to;
- the element from the source being accumulated.
Return a HashMap
associating the key of each group with the result of folding that group’s elements.
use itertools::Itertools;
let lookup = (1..=7)
.into_grouping_map_by(|&n| n % 3)
.fold_first(|acc, _key, val| acc + val);
assert_eq!(lookup[&0], 3 + 6);
assert_eq!(lookup[&1], 1 + 4 + 7);
assert_eq!(lookup[&2], 2 + 5);
assert_eq!(lookup.len(), 3);
sourcepub fn collect<C>(self) -> HashMap<K, C, RandomState> where
C: Default + Extend<V>,
pub fn collect<C>(self) -> HashMap<K, C, RandomState> where
C: Default + Extend<V>,
Groups elements from the GroupingMap
source by key and collects the elements of each group in
an instance of C
. The iteration order is preserved when inserting elements.
Return a HashMap
associating the key of each group with the collection containing that group’s elements.
use itertools::Itertools;
use std::collections::HashSet;
let lookup = vec![0, 1, 2, 3, 4, 5, 6, 2, 3, 6].into_iter()
.into_grouping_map_by(|&n| n % 3)
.collect::<HashSet<_>>();
assert_eq!(lookup[&0], vec![0, 3, 6].into_iter().collect::<HashSet<_>>());
assert_eq!(lookup[&1], vec![1, 4].into_iter().collect::<HashSet<_>>());
assert_eq!(lookup[&2], vec![2, 5].into_iter().collect::<HashSet<_>>());
assert_eq!(lookup.len(), 3);
sourcepub fn max(self) -> HashMap<K, V, RandomState> where
V: Ord,
pub fn max(self) -> HashMap<K, V, RandomState> where
V: Ord,
Groups elements from the GroupingMap
source by key and finds the maximum of each group.
If several elements are equally maximum, the last element is picked.
Returns a HashMap
associating the key of each group with the maximum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.max();
assert_eq!(lookup[&0], 12);
assert_eq!(lookup[&1], 7);
assert_eq!(lookup[&2], 8);
assert_eq!(lookup.len(), 3);
sourcepub fn max_by<F>(self, compare: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_, '_> FnMut(&K, &V, &V) -> Ordering,
pub fn max_by<F>(self, compare: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_, '_> FnMut(&K, &V, &V) -> Ordering,
Groups elements from the GroupingMap
source by key and finds the maximum of each group
with respect to the specified comparison function.
If several elements are equally maximum, the last element is picked.
Returns a HashMap
associating the key of each group with the maximum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.max_by(|_key, x, y| y.cmp(x));
assert_eq!(lookup[&0], 3);
assert_eq!(lookup[&1], 1);
assert_eq!(lookup[&2], 5);
assert_eq!(lookup.len(), 3);
sourcepub fn max_by_key<F, CK>(self, f: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_> FnMut(&K, &V) -> CK,
CK: Ord,
pub fn max_by_key<F, CK>(self, f: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_> FnMut(&K, &V) -> CK,
CK: Ord,
Groups elements from the GroupingMap
source by key and finds the element of each group
that gives the maximum from the specified function.
If several elements are equally maximum, the last element is picked.
Returns a HashMap
associating the key of each group with the maximum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.max_by_key(|_key, &val| val % 4);
assert_eq!(lookup[&0], 3);
assert_eq!(lookup[&1], 7);
assert_eq!(lookup[&2], 5);
assert_eq!(lookup.len(), 3);
sourcepub fn min(self) -> HashMap<K, V, RandomState> where
V: Ord,
pub fn min(self) -> HashMap<K, V, RandomState> where
V: Ord,
Groups elements from the GroupingMap
source by key and finds the minimum of each group.
If several elements are equally minimum, the first element is picked.
Returns a HashMap
associating the key of each group with the minimum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.min();
assert_eq!(lookup[&0], 3);
assert_eq!(lookup[&1], 1);
assert_eq!(lookup[&2], 5);
assert_eq!(lookup.len(), 3);
sourcepub fn min_by<F>(self, compare: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_, '_> FnMut(&K, &V, &V) -> Ordering,
pub fn min_by<F>(self, compare: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_, '_> FnMut(&K, &V, &V) -> Ordering,
Groups elements from the GroupingMap
source by key and finds the minimum of each group
with respect to the specified comparison function.
If several elements are equally minimum, the first element is picked.
Returns a HashMap
associating the key of each group with the minimum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.min_by(|_key, x, y| y.cmp(x));
assert_eq!(lookup[&0], 12);
assert_eq!(lookup[&1], 7);
assert_eq!(lookup[&2], 8);
assert_eq!(lookup.len(), 3);
sourcepub fn min_by_key<F, CK>(self, f: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_> FnMut(&K, &V) -> CK,
CK: Ord,
pub fn min_by_key<F, CK>(self, f: F) -> HashMap<K, V, RandomState> where
F: for<'_, '_> FnMut(&K, &V) -> CK,
CK: Ord,
Groups elements from the GroupingMap
source by key and finds the element of each group
that gives the minimum from the specified function.
If several elements are equally minimum, the first element is picked.
Returns a HashMap
associating the key of each group with the minimum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.min_by_key(|_key, &val| val % 4);
assert_eq!(lookup[&0], 12);
assert_eq!(lookup[&1], 4);
assert_eq!(lookup[&2], 8);
assert_eq!(lookup.len(), 3);
sourcepub fn minmax(self) -> HashMap<K, MinMaxResult<V>, RandomState> where
V: Ord,
pub fn minmax(self) -> HashMap<K, MinMaxResult<V>, RandomState> where
V: Ord,
Groups elements from the GroupingMap
source by key and find the maximum and minimum of
each group.
If several elements are equally maximum, the last element is picked. If several elements are equally minimum, the first element is picked.
See .minmax() for the non-grouping version.
Differences from the non grouping version:
- It never produces a
MinMaxResult::NoElements
- It doesn’t have any speedup
Returns a HashMap
associating the key of each group with the minimum and maximum of that group’s elements.
use itertools::Itertools;
use itertools::MinMaxResult::{OneElement, MinMax};
let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.minmax();
assert_eq!(lookup[&0], MinMax(3, 12));
assert_eq!(lookup[&1], MinMax(1, 7));
assert_eq!(lookup[&2], OneElement(5));
assert_eq!(lookup.len(), 3);
sourcepub fn minmax_by<F>(
self,
compare: F
) -> HashMap<K, MinMaxResult<V>, RandomState> where
F: for<'_, '_, '_> FnMut(&K, &V, &V) -> Ordering,
pub fn minmax_by<F>(
self,
compare: F
) -> HashMap<K, MinMaxResult<V>, RandomState> where
F: for<'_, '_, '_> FnMut(&K, &V, &V) -> Ordering,
Groups elements from the GroupingMap
source by key and find the maximum and minimum of
each group with respect to the specified comparison function.
If several elements are equally maximum, the last element is picked. If several elements are equally minimum, the first element is picked.
It has the same differences from the non-grouping version as minmax
.
Returns a HashMap
associating the key of each group with the minimum and maximum of that group’s elements.
use itertools::Itertools;
use itertools::MinMaxResult::{OneElement, MinMax};
let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.minmax_by(|_key, x, y| y.cmp(x));
assert_eq!(lookup[&0], MinMax(12, 3));
assert_eq!(lookup[&1], MinMax(7, 1));
assert_eq!(lookup[&2], OneElement(5));
assert_eq!(lookup.len(), 3);
sourcepub fn minmax_by_key<F, CK>(
self,
f: F
) -> HashMap<K, MinMaxResult<V>, RandomState> where
F: for<'_, '_> FnMut(&K, &V) -> CK,
CK: Ord,
pub fn minmax_by_key<F, CK>(
self,
f: F
) -> HashMap<K, MinMaxResult<V>, RandomState> where
F: for<'_, '_> FnMut(&K, &V) -> CK,
CK: Ord,
Groups elements from the GroupingMap
source by key and find the elements of each group
that gives the minimum and maximum from the specified function.
If several elements are equally maximum, the last element is picked. If several elements are equally minimum, the first element is picked.
It has the same differences from the non-grouping version as minmax
.
Returns a HashMap
associating the key of each group with the minimum and maximum of that group’s elements.
use itertools::Itertools;
use itertools::MinMaxResult::{OneElement, MinMax};
let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.minmax_by_key(|_key, &val| val % 4);
assert_eq!(lookup[&0], MinMax(12, 3));
assert_eq!(lookup[&1], MinMax(4, 7));
assert_eq!(lookup[&2], OneElement(5));
assert_eq!(lookup.len(), 3);
sourcepub fn sum(self) -> HashMap<K, V, RandomState> where
V: Add<V, Output = V>,
pub fn sum(self) -> HashMap<K, V, RandomState> where
V: Add<V, Output = V>,
Groups elements from the GroupingMap
source by key and sums them.
This is just a shorthand for self.fold_first(|acc, _, val| acc + val)
.
It is more limited than Iterator::sum
since it doesn’t use the Sum
trait.
Returns a HashMap
associating the key of each group with the sum of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.sum();
assert_eq!(lookup[&0], 3 + 9 + 12);
assert_eq!(lookup[&1], 1 + 4 + 7);
assert_eq!(lookup[&2], 5 + 8);
assert_eq!(lookup.len(), 3);
sourcepub fn product(self) -> HashMap<K, V, RandomState> where
V: Mul<V, Output = V>,
pub fn product(self) -> HashMap<K, V, RandomState> where
V: Mul<V, Output = V>,
Groups elements from the GroupingMap
source by key and multiply them.
This is just a shorthand for self.fold_first(|acc, _, val| acc * val)
.
It is more limited than Iterator::product
since it doesn’t use the Product
trait.
Returns a HashMap
associating the key of each group with the product of that group’s elements.
use itertools::Itertools;
let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
.into_grouping_map_by(|&n| n % 3)
.product();
assert_eq!(lookup[&0], 3 * 9 * 12);
assert_eq!(lookup[&1], 1 * 4 * 7);
assert_eq!(lookup[&2], 5 * 8);
assert_eq!(lookup.len(), 3);
Trait Implementations
sourceimpl<I> Clone for GroupingMap<I> where
I: Clone,
impl<I> Clone for GroupingMap<I> where
I: Clone,
sourcefn clone(&self) -> GroupingMap<I>
fn clone(&self) -> GroupingMap<I>
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
Auto Trait Implementations
impl<I> RefUnwindSafe for GroupingMap<I> where
I: RefUnwindSafe,
impl<I> Send for GroupingMap<I> where
I: Send,
impl<I> Sync for GroupingMap<I> where
I: Sync,
impl<I> Unpin for GroupingMap<I> where
I: Unpin,
impl<I> UnwindSafe for GroupingMap<I> where
I: UnwindSafe,
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> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
Use this to cast from one trait object type to another. Read more
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
Use this to upcast a trait to one of its supertraits. Read more
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more