Struct 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

source

impl<I, K, V> GroupingMap where
I: Iterator<Item = (K, V)>,
K: Hash + Eq,

source

pub fn aggregate<FO, R>(self, operation: FO) -> HashMap<K, R> where
FO: 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

source

pub fn fold<FO, R>(self, init: R, operation: FO) -> HashMap<K, R> where
R: Clone,
FO: 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);

source

pub fn fold_first<FO>(self, operation: FO) -> HashMap<K, V> where
FO: 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);

source

pub fn collect<C>(self) -> HashMap<K, C> 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);

source

pub fn max(self) -> HashMap<K, V> 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);

source

pub fn max_by<F>(self, compare: F) -> HashMap<K, V> where
F: 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);

source

pub fn max_by_key<F, CK>(self, f: F) -> HashMap<K, V> where
F: 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);

source

pub fn min(self) -> HashMap<K, V> 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);

source

pub fn min_by<F>(self, compare: F) -> HashMap<K, V> where
F: 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);

source

pub fn min_by_key<F, CK>(self, f: F) -> HashMap<K, V> where
F: 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);

source

pub fn minmax(self) -> HashMap<K, MinMaxResult<V>> 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);

source

pub fn minmax_by<F>(self, compare: F) -> HashMap<K, MinMaxResult<V>> where
F: 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);

source

pub fn minmax_by_key<F, CK>(self, f: F) -> HashMap<K, MinMaxResult<V>> where
F: 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);

source

pub fn sum(self) -> HashMap<K, V> 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);

source

pub fn product(self) -> HashMap<K, V> 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

source

impl<I: Clone> Clone for GroupingMap

source

fn clone(&self) -> GroupingMap

Returns a copy of the value. Read more

1.0.0 · source

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

source

impl<I: Debug> Debug for GroupingMap

source

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations

impl RefUnwindSafe for GroupingMap where
I: RefUnwindSafe,

impl Send for GroupingMap where
I: Send,

impl Sync for GroupingMap where
I: Sync,

impl Unpin for GroupingMap where
I: Unpin,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct itertools::structs::GroupingMap

Implementations

impl<I, K, V> GroupingMap<I> where I: Iterator<Item = (K, V)>, K: Hash + Eq,

pub fn aggregate<FO, R>(self, operation: FO) -> HashMap<K, R> where FO: FnMut(Option<R>, &K, V) -> Option<R>,

pub fn fold<FO, R>(self, init: R, operation: FO) -> HashMap<K, R> where R: Clone, FO: FnMut(R, &K, V) -> R,

pub fn fold_first<FO>(self, operation: FO) -> HashMap<K, V> where FO: FnMut(V, &K, V) -> V,

pub fn collect<C>(self) -> HashMap<K, C> where C: Default + Extend<V>,

pub fn max(self) -> HashMap<K, V> where V: Ord,

pub fn max_by<F>(self, compare: F) -> HashMap<K, V> where F: FnMut(&K, &V, &V) -> Ordering,

pub fn max_by_key<F, CK>(self, f: F) -> HashMap<K, V> where F: FnMut(&K, &V) -> CK, CK: Ord,

pub fn min(self) -> HashMap<K, V> where V: Ord,

pub fn min_by<F>(self, compare: F) -> HashMap<K, V> where F: FnMut(&K, &V, &V) -> Ordering,

pub fn min_by_key<F, CK>(self, f: F) -> HashMap<K, V> where F: FnMut(&K, &V) -> CK, CK: Ord,

pub fn minmax(self) -> HashMap<K, MinMaxResult<V>> where V: Ord,

pub fn minmax_by<F>(self, compare: F) -> HashMap<K, MinMaxResult<V>> where F: FnMut(&K, &V, &V) -> Ordering,

pub fn minmax_by_key<F, CK>(self, f: F) -> HashMap<K, MinMaxResult<V>> where F: FnMut(&K, &V) -> CK, CK: Ord,

pub fn sum(self) -> HashMap<K, V> where V: Add<V, Output = V>,

pub fn product(self) -> HashMap<K, V> where V: Mul<V, Output = V>,

Trait Implementations

impl<I: Clone> Clone for GroupingMap<I>

fn clone(&self) -> GroupingMap<I>

fn clone_from(&mut self, source: &Self)

impl<I: Debug> Debug for GroupingMap<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

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

impl<T> Any for T where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

fn into(self) -> U

impl<T> ToOwned for T where T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<I, K, V> GroupingMap<I> where
I: Iterator<Item = (K, V)>,
K: Hash + Eq,

pub fn aggregate<FO, R>(self, operation: FO) -> HashMap<K, R> where
FO: FnMut(Option<R>, &K, V) -> Option<R>,

pub fn fold<FO, R>(self, init: R, operation: FO) -> HashMap<K, R> where
R: Clone,
FO: FnMut(R, &K, V) -> R,

pub fn fold_first<FO>(self, operation: FO) -> HashMap<K, V> where
FO: FnMut(V, &K, V) -> V,

pub fn collect<C>(self) -> HashMap<K, C> where
C: Default + Extend<V>,

pub fn max(self) -> HashMap<K, V> where
V: Ord,

pub fn max_by<F>(self, compare: F) -> HashMap<K, V> where
F: FnMut(&K, &V, &V) -> Ordering,

pub fn max_by_key<F, CK>(self, f: F) -> HashMap<K, V> where
F: FnMut(&K, &V) -> CK,
CK: Ord,

pub fn min(self) -> HashMap<K, V> where
V: Ord,

pub fn min_by<F>(self, compare: F) -> HashMap<K, V> where
F: FnMut(&K, &V, &V) -> Ordering,

pub fn min_by_key<F, CK>(self, f: F) -> HashMap<K, V> where
F: FnMut(&K, &V) -> CK,
CK: Ord,

pub fn minmax(self) -> HashMap<K, MinMaxResult<V>> where
V: Ord,

pub fn minmax_by<F>(self, compare: F) -> HashMap<K, MinMaxResult<V>> where
F: FnMut(&K, &V, &V) -> Ordering,

pub fn minmax_by_key<F, CK>(self, f: F) -> HashMap<K, MinMaxResult<V>> where
F: FnMut(&K, &V) -> CK,
CK: Ord,

pub fn sum(self) -> HashMap<K, V> where
V: Add<V, Output = V>,

pub fn product(self) -> HashMap<K, V> where
V: Mul<V, Output = V>,

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,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,