Prelude / MultiMap

MultiMap

enum MultiMap[k: Type, v: Type]Source

case MultiMap(Map[k, Set[v]])

Type of immutable maps that allow multiple values per key.

Multiple values are stored in a Set so duplicates are not allowed.

The key and value types must implement the Eq and Order traits.

Type of immutable maps that allow multiple values per key, and its functions.

Instances

instance CommutativeMonoid[MultiMap[k, v]] with Order[k], Order[v]Source

instance CommutativeSemiGroup[MultiMap[k, v]] with Order[k], Order[v]Source

instance Eq[MultiMap[k, v]] with Eq[k], Eq[v]Source

instance Foldable[MultiMap[k]]Source

instance Formattable[MultiMap[k, v]] with Formattable[k], Formattable[v]Source

type Aef = Aef[k] + Aef[v]

instance Hash[MultiMap[k, v]] with Hash[k], Hash[v]Source

instance Indexable[MultiMap[k, v]] with Order[k]Source

type Idx = ktype Elm = Set[v]type Aef = KeyNotFound

instance Monoid[MultiMap[k, v]] with Order[k], Order[v]Source

instance Order[MultiMap[k, v]] with Order[k], Order[v]Source

instance SemiGroup[MultiMap[k, v]] with Order[k], Order[v]Source

instance ToString[MultiMap[k, v]] with ToString[k], ToString[v]Source

instance UnorderedFoldable[MultiMap[k]]Source

Definitions

def adjust(f: v -> v \ ef, k: k, m: MultiMap[k, v]): MultiMap[k, v] \ ef with Order[k], Order[v]§ Source

Updates m with k => map(f, vs) if k => vs is in m.

Otherwise, returns m.

def adjustWithKey(f: k -> (v -> v \ ef), k: k, m: MultiMap[k, v]): MultiMap[k, v] \ ef with Order[k], Order[v]§ Source

Updates m with k => map(f(k), vs) if k => vs is in m. Otherwise, returns m.

@ParallelWhenPure

def count(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): Int32 \ ef§ Source

Returns the number of mappings k => v in m that satisfy the predicate f.

Purity reflective: Runs in parallel when given a pure function f.

def difference(m1: MultiMap[k, v], m2: MultiMap[k, v]): MultiMap[k, v] with Order[k], Order[v]§ Source

Returns the difference of m1 and m2 i.e m1 - m2 (left biased).

def empty(): MultiMap[k, v]§ Source

Returns the empty MultiMap.

def exists(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): Bool \ ef§ Source

Returns true if and only if at least one mapping in m satisfies the predicate f.

Returns false if m is the empty MultiMap.

def filter(f: v -> Bool \ ef, m: MultiMap[k, v]): MultiMap[k, v] \ ef with Order[k], Order[v]§ Source

Returns a MultiMap of all mappings k => v in m where v satisfies the predicate f.

def filterWithKey(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): MultiMap[k, v] \ ef with Order[k], Order[v]§ Source

Returns a MultiMap of all mappings k => v in m where (k, v) satisfies the predicate f.

def find(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): Option[(k, v)] \ ef§ Source

Alias for findLeft.

def findLeft(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): Option[(k, v)] \ ef§ Source

Optionally returns the first mapping of m that satisfies the predicate f when searching from left to right.

def findRight(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): Option[(k, v)] \ ef§ Source

Optionally returns the first mapping of m that satisfies the predicate f when searching from right to left.

def foldLeft(f: b -> (v -> b \ ef), s: b, m: MultiMap[k, v]): b \ ef§ Source

Applies f to a start value s and all values in m going from left to right.

That is, the result is of the form: f(...f(f(s, v1), v2)..., vn).

def foldLeftWithKey(f: b -> (k -> (v -> b \ ef)), s: b, m: MultiMap[k, v]): b \ ef§ Source

Applies f to a start value s and all key-value pairs in m going from left to right.

That is, the result is of the form: f(...f(f(s, k1, v1), k2, v2)..., vn).

def foldMap(f: v -> b \ ef, m: MultiMap[k, v]): b \ ef with Monoid[b]§ Source

Returns the result of mapping each value and combining the results.

def foldMapWithKey(f: k -> (v -> b \ ef), m: MultiMap[k, v]): b \ ef with Monoid[b]§ Source

Returns the result of mapping each key-value pair and combining the results.

def foldRight(f: v -> (b -> b \ ef), s: b, m: MultiMap[k, v]): b \ ef§ Source

Applies f to a start value s and all values in m going from right to left.

That is, the result is of the form: f(v1, ...f(vn-1, f(vn, s))).

def foldRightWithKey(f: k -> (v -> (b -> b \ ef)), s: b, m: MultiMap[k, v]): b \ ef§ Source

Applies f to a start value s and all key-value pairs in m going from right to left.

That is, the result is of the form: f(k1, v1, ...f(kn-1, vn-1, f(kn, vn, s))).

def foldWithKey(f: b -> (k -> (v -> b \ ef)), s: b, m: MultiMap[k, v]): b \ ef§ Source

Alias for foldLeftWithKey.

def forAll(f: k -> (v -> Bool \ ef), m: MultiMap[k, v]): Bool \ ef§ Source

Returns true if and only if all mappings in m satisfy the predicate f.

Returns true if m is the empty MultiMap.

def forEach(f: k -> (v -> Unit \ ef), m: MultiMap[k, v]): Unit \ ef§ Source

Applies f to every (key, value) of MultiMap m.

def forEachWithIndex(f: Int32 -> (k -> (v -> Unit \ ef)), m: MultiMap[k, v]): Unit \ ef§ Source

Applies f to tuple (index, key, value) formed of the keys and values of MultiMap m and the index of the traversal.

def get(k: k, m: MultiMap[k, v]): Set[v] with Order[k]§ Source

Returns Some(vs) if k => vs is in m.

Otherwise returns Set.empty().

def insert(k: k, v: v, m: MultiMap[k, v]): MultiMap[k, v] with Order[k], Order[v]§ Source

Updates m with k => Set.union(v, v0) if k => v0 is in m.

Otherwise, returns m with k => Set.singleton(v).

def insertAll(k: k, vs: t[v], m: MultiMap[k, v]): MultiMap[k, v] \ Aef[t] with Order[k], Order[v], Foldable[t]§ Source

Updates m with k => vs.

Where vs is any foldable container. If vs is empty nothing is inserted.

def intersection(m1: MultiMap[k, v], m2: MultiMap[k, v]): MultiMap[k, v] with Order[k], Order[v]§ Source

Returns the intersection of m1 and m2.

def isEmpty(m: MultiMap[k, v]): Bool§ Source

Returns true if and only if m is the empty MultiMap.

def iterator(rc: Region[r], m: MultiMap[k, v]): Iterator[(k, Set[v]), r, r] \ r§ Source

Returns an iterator over all key-value pairs in m i.e. k => Set#{v_1, ..., v_n}.

def keysOf(m: MultiMap[k, v]): Set[k] with Order[k]§ Source

Returns the keys of m.

@ParallelWhenPure

def map(f: v1 -> v2 \ ef, m: MultiMap[k, v1]): MultiMap[k, v2] \ ef with Order[v2]§ Source

Returns a MultiMap with mappings k => f(v) for every k => v in m.

Purity reflective: Runs in parallel when given a pure function f.

@ParallelWhenPure

def mapWithKey(f: k -> (v1 -> v2 \ ef), m: MultiMap[k, v1]): MultiMap[k, v2] \ ef with Order[v2]§ Source

Returns a MultiMap with mappings k => f(k, v) for every k => v in m.

Purity reflective: Runs in parallel when given a pure function f.

def memberOf(k: k, m: MultiMap[k, v]): Bool with Order[k]§ Source

Returns true if and only if m contains the key k.

def nonEmpty(m: MultiMap[k, v]): Bool§ Source

Returns true if and only if m is a non-empty MultiMap.

def reduceLeft(f: v -> (v -> v \ ef), m: MultiMap[k, v]): Option[v] \ ef§ Source

Applies f to all values in m going from left to right until a single value v is obtained. Returns Some(v).

That is, the result is of the form: Some(f(...f(f(v1, v2), v3)..., vn))

Returns None if m is the empty MultiMap.

def reduceLeftWithKey(f: k -> (v -> (k -> (v -> (k, v) \ ef))), m: MultiMap[k, v]): Option[(k, v)] \ ef§ Source

Applies f to all mappings in m going from left to right until a single mapping (k, v) is obtained. Returns Some((k, v)).

That is, the result is of the form: Some(f(...f(f(k1, v1, k2, v2), k3, v3)..., kn, vn))

Returns None if m is the empty MultiMap.

def reduceRight(f: v -> (v -> v \ ef), m: MultiMap[k, v]): Option[v] \ ef§ Source

Applies f to all values in m going from right to left until a single value v is obtained. Returns Some(v).

That is, the result is of the form: Some(f(v1, ...f(vn-2, f(vn-1, vn))...))

Returns None if m is the empty MultiMap.

def reduceRightWithKey(f: k -> (v -> (k -> (v -> (k, v) \ ef))), m: MultiMap[k, v]): Option[(k, v)] \ ef§ Source

Applies f to all mappings in m going from right to left until a single mapping (k, v) is obtained. Returns Some((k, v)).

That is, the result is of the form: Some(f(k1, v1, ...f(kn-2, vn-2, f(kn-1, vn-1, kn, vn))...))

Returns None if m is the empty MultiMap.

def remove(k: k, m: MultiMap[k, v]): MultiMap[k, v] with Order[k]§ Source

Removes the mapping k from the MultiMap m.

def removeWithValue(k: k, v: v, m: MultiMap[k, v]): MultiMap[k, v] with Order[k], Order[v]§ Source

Removes the mapping of (k, v) from the MultiMap m if it exists.

def singleton(k: k, v: v): MultiMap[k, v] with Order[k], Order[v]§ Source

Returns the singleton MultiMap where key k is mapped to value v.

def size(m: MultiMap[k, v]): Int32§ Source

Returns the number of keys in m.

def toAscList(m: MultiMap[k, v]): List[(k, v)]§ Source

Returns the MultiMap m as a list of singleton key-value pairs in ascending order.

def toAssocList(m: MultiMap[k, v]): List[(k, Set[v])]§ Source

Returns the MultiMap m as a list of (key, Set[value]) pairs in ascending order.

def toDescList(m: MultiMap[k, v]): List[(k, v)]§ Source

Returns the MultiMap m as a list of singleton key-value pairs in descending order.

def toList(m: MultiMap[k, v]): List[(k, v)]§ Source

Returns the MultiMap m as a list of singleton key-value pairs.

def toMap(m: MultiMap[k, v]): Map[k, Set[v]]§ Source

Returns the MultiMap m as a list of singleton key-value pairs in ascending order.

def toString(m: MultiMap[k, v]): String with ToString[k], ToString[v]§ Source

Returns a string representation of m.

def union(m1: MultiMap[k, v], m2: MultiMap[k, v]): MultiMap[k, v] with Order[k], Order[v]§ Source

Returns the union of m1 and m2.

def update(f: v -> Option[v] \ ef, k: k, m: MultiMap[k, v]): MultiMap[k, v] \ ef with Order[k], Order[v]§ Source

Updates m with k => v1 if k => v is in m and f(v) = Some(v1). Otherwise, returns m.

def updateWithKey(f: k -> (v -> Option[v] \ ef), k: k, m: MultiMap[k, v]): MultiMap[k, v] \ ef with Order[k], Order[v]§ Source

Updates m with k => v1 if k => v is in m and f(k, v) = Some(v1). Otherwise, returns m.

def valuesOf(m: MultiMap[k, v]): List[v] with Order[k]§ Source

Returns the values of m.

Answer may contain duplicates where values were ascribed to multiple keys.