Struct naan::impls::hash_map::hkt::HashMapValues

pub struct HashMapValues<K>(_);

std::collections::HashMap lifted to an HKT1 with a fixed key type

(Kind Type -> Type)

Trait Implementations

impl<K, A> Alt<HashMapValues<K>, A> for HashMap<K, A>where K: Eq + Hash,

fn alt(self, b: Self) -> Self

Combine the two maps, preferring keys from self when self and b both have an entry for a given key.

use std::collections::HashMap;

use naan::prelude::*;

let a_union_b = HashMap::from([("a", 1), ("b", 2)]).alt(HashMap::from([("b", 3), ("c", 3)]));
assert_eq!(a_union_b, HashMap::from([("a", 1), ("b", 2), ("c", 3)]))

impl<K, AB> Apply<HashMapValues<K>, AB> for HashMap<K, AB>where K: Eq + Hash,

fn apply_with<A, B, Cloner>( self, as_: HashMap<K, A>, cloner: Cloner ) -> HashMap<K, B>where AB: F1<A, Ret = B>, Cloner: for<'a> F1<&'a A, Ret = A>,

Apply the function A -> B contained in Self (F<A -> B>) to an instance of F<A> to get F<B>.

fn apply<A, B>(self, a: F::T<A>) -> F::T<B>where Self: Sized, AB: F1<A, Ret = B>, A: Clone,

See [Apply.apply_with]

impl<A, K> Foldable<HashMapValues<K>, A> for HashMap<K, A>where K: Eq + Hash,

fn foldl<B, BAB>(self, f: BAB, b: B) -> Bwhere BAB: F2<B, A, Ret = B>,

Fold the data structure from left -> right

fn foldr<B, ABB>(self, f: ABB, b: B) -> Bwhere ABB: F2<A, B, Ret = B>,

Fold the data structure from right -> left

fn foldl_ref<'a, B, BAB>(&'a self, f: BAB, b: B) -> Bwhere BAB: F2<B, &'a A, Ret = B>, A: 'a,

Fold the data structure from left -> right

fn foldr_ref<'a, B, ABB>(&'a self, f: ABB, b: B) -> Bwhere ABB: F2<&'a A, B, Ret = B>, A: 'a,

Fold the data structure from right -> left

fn fold_map<AB, B>(self, f: AB) -> Bwhere Self: Sized, AB: F1<A, Ret = B>, B: Monoid,

Fold the data structure, accumulating the values into a Monoid.

fn contains<'a>(&'a self, a: &'a A) -> boolwhere &'a A: PartialEq, A: 'a,

Test if the structure contains a value a

fn not_contains<'a>(&'a self, a: &'a A) -> boolwhere &'a A: PartialEq, A: 'a,

Test if the structure does not contain a value a

fn any<'a, P>(&'a self, f: P) -> boolwhere P: F1<&'a A, Ret = bool>, A: 'a,

Test if any element in the structure satisfies a predicate f

fn all<'a, P>(&'a self, f: P) -> boolwhere P: F1<&'a A, Ret = bool>, A: 'a,

Test if every element in the structure satisfies a predicate f

fn length(&self) -> usize

Get the number of elements contained within the structure

fn is_empty(&self) -> bool

Test if the structure is empty

fn find_map<AB, B>(self, f: AB) -> Option<B>where Self: Sized, AB: F1<A, Ret = Option<B>>,

Fold values until a match is found

fn find<P>(self, f: P) -> Option<A>where Self: Sized, P: for<'a> F1<&'a A, Ret = bool>,

Fold values until a match is found

impl<A, K> FoldableIndexed<HashMapValues<K>, K, A> for HashMap<K, A>where K: Eq + Hash + Clone,

fn foldl_idx<B, BAB>(self, f: BAB, b: B) -> Bwhere BAB: F3<B, K, A, Ret = B>,

Fold the data structure from left -> right

fn foldr_idx<B, ABB>(self, f: ABB, b: B) -> Bwhere ABB: F3<K, A, B, Ret = B>,

Fold the data structure from right -> left

fn foldl_idx_ref<'a, B, BAB>(&'a self, f: BAB, b: B) -> Bwhere BAB: F3<B, K, &'a A, Ret = B>, A: 'a,

Fold the data structure from left -> right

fn foldr_idx_ref<'a, B, ABB>(&'a self, f: ABB, b: B) -> Bwhere ABB: F3<K, &'a A, B, Ret = B>, A: 'a,

Fold the data structure from right -> left

impl<K, A> Functor<HashMapValues<K>, A> for HashMap<K, A>where K: Hash + Eq,

fn fmap<AB, B>(self, f: AB) -> HashMap<K, B>where AB: F1<A, Ret = B>,

Use a function from A -> B to transform an F<A> to an F<B>.

impl<K> HKT1 for HashMapValues<K>where K: Hash + Eq,

type T<A> = HashMap<K, A, RandomState>

The generic type

impl<K, A> Plus<HashMapValues<K>, A> for HashMap<K, A>where K: Eq + Hash,

fn empty() -> <HashMapValues<K> as HKT1>::T<A>

See Plus

impl<K, A, B> Traversable<HashMapValues<K>, A, B, Curry3<fn(_: K, _: B, _: HashMap<K, B, RandomState>) -> HashMap<K, B, RandomState>, Just<K>, Just<B>, Nothing<HashMap<K, B, RandomState>>, HashMap<K, B, RandomState>>> for HashMap<K, A>where K: Clone + Eq + Hash, HashMapValues<K>: HKT1<T<B> = HashMap<K, B>>,

fn traversem1<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<HashMap<K, B>>where Ap: HKT1, Self: Foldable<HashMapValues<K>, A>, Ap::T<B>: Applicative<Ap, B> + ApplyOnce<Ap, B>, Ap::T<insert2<K, B>>: Applicative<Ap, insert2<K, B>> + ApplyOnce<Ap, insert2<K, B>>, Ap::T<HashMap<K, B>>: Applicative<Ap, HashMap<K, B>> + ApplyOnce<Ap, HashMap<K, B>>, AtoApOfB: F1<A, Ret = Ap::T<B>>, HashMapValues<K>: HKT1<T<A> = Self>,

Traverse a structure with 0 or more elements, collecting into an Applicative of 0 or 1 elements.

fn traversemm<Ap, AtoApOfB>(self, f: AtoApOfB) -> Ap::T<HashMap<K, B>>where Ap: HKT1, Self: Foldable<HashMapValues<K>, A>, B: Clone, Ap::T<B>: Applicative<Ap, B>, Ap::T<insert2<K, B>>: Applicative<Ap, insert2<K, B>>, Ap::T<HashMap<K, B>>: Applicative<Ap, HashMap<K, B>>, AtoApOfB: F1<A, Ret = Ap::T<B>>, HashMapValues<K>: HKT1<T<A> = Self>,

Traverse a structure with 0 or more elements, collecting into an Applicative of 0 or more elements.