Trait protocoll::MapMut [−] [src]

pub trait MapMut<K, V> {
    fn update_mut<F>(&mut self, k: K, fnil: V, f: F)
    where
        F: FnOnce(&mut V);
    fn update_all_mut<F>(&mut self, f: F)
    where
        F: FnMut(&K, &mut V);
    fn merge_mut<I, F>(&mut self, coll: I, f: F)
    where
        I: IntoIterator<Item = (K, V)>,
        F: FnMut(&mut V, V);
}

Required Methods

like Map::update but can be more efficient.

example

use protocoll::{Map,MapMut};
use std::collections::HashMap;
let a = [0,0,0,1,1,0,0,0];
let m1 = a.iter().fold
    (HashMap::new(), |m,&k| Map::update
     (m, k, |n| 1 + n.unwrap_or(0)));
let m2 = a.iter().fold
    (HashMap::new(), |mut m, &k|
     {m.update_mut(k, 0, |n| *n += 1); m});
assert_eq!(m1,m2);

like Map::update_all but can be more efficient.

example

use protocoll::MapMut;
use std::collections::HashMap;
let mut m = [0,0,0,1,1,0,0,0].iter().fold
    (HashMap::new(), |mut m, &k|
     {m.update_mut(k, 0, |n| *n += 1); m});
m.update_all_mut(|_,v| *v += 1);
assert_eq!(7, m[&0]);
assert_eq!(3, m[&1]);

like Map::merge but can be more efficient.

example

use protocoll::MapMut;
use std::collections::HashMap;
let m1 = [0,0,0,1,1,0,0,0].iter().fold
    (HashMap::new(), |mut m, &k|
     {m.update_mut(k, 0, |n| *n += 1); m});
let mut m2 = m1.clone();
m2.merge_mut(m1, |u,v| *u += v);
assert_eq!(12, m2[&0]);
assert_eq!(4, m2[&1]);

Implementors