Std.MultiMap

30 public declarations

• add&Std.MultiMap.MultiMap[K, V] -> K -> V -> Std.MultiMap.MultiMap[K, V]

  The map with a value added under a key, after any already there.

  fn
• addAll&Std.MultiMap.MultiMap[K, V] -> K -> &Array[V] -> Std.MultiMap.MultiMap[K, V]

  The map with several values added under a key, in the order given.

  fn
• all&Std.MultiMap.MultiMap[K, V] -> fn(K, V) -> Bool -> Bool

  Whether every value satisfies the predicate. True for an empty map.

  fn
• any&Std.MultiMap.MultiMap[K, V] -> fn(K, V) -> Bool -> Bool

  Whether any value satisfies the predicate. False for an empty map.

  fn
• contains&Std.MultiMap.MultiMap[K, V] -> K -> V -> Bool

  Whether a key has this particular value.

  fn
• containsKey&Std.MultiMap.MultiMap[K, V] -> K -> Bool

  Whether a key has any value.

  fn
• count&Std.MultiMap.MultiMap[K, V] -> K -> Int

  How many values a key has.

  fn
• emptyStd.MultiMap.MultiMap[K, V]

  A map with no entries.

  fn
• filterKeys&Std.MultiMap.MultiMap[K, V] -> fn(K) -> Bool -> Std.MultiMap.MultiMap[K, V]

  Only the keys the predicate accepts.

  fn
• filterValues&Std.MultiMap.MultiMap[K, V] -> fn(V) -> Bool -> Std.MultiMap.MultiMap[K, V]

  Only the values the predicate accepts, dropping keys left with none.

  fn
• fold&Std.MultiMap.MultiMap[K, V] -> fn(A, K, Array[V]) -> A -> A -> A

  Every key and all its values combined into one value, in key order.

  fn
• fromPairs&Array[(K, V)] -> Std.MultiMap.MultiMap[K, V]

  A map built from pairs, collecting values under their shared keys.

  fn
• get&Std.MultiMap.MultiMap[K, V] -> K -> Array[V]

  Every value under a key, in the order they were added, or an empty array.

  fn
• groupBy&Array[T] -> fn(T) -> K -> Std.MultiMap.MultiMap[K, T]

  Items collected under the key each one produces.

  fn
• groups&Std.MultiMap.MultiMap[K, V] -> Array[(K, Array[V])]

  Every key paired with all of its values, in key order.

  fn
• inverted&Std.MultiMap.MultiMap[K, V] -> Std.MultiMap.MultiMap[V, K]

  The map with its keys and values exchanged.

  fn
• isEmpty&Std.MultiMap.MultiMap[K, V] -> Bool

  Whether the map holds nothing.

  fn
• keys&Std.MultiMap.MultiMap[K, V] -> Array[K]

  Every key that has values, in order.

  fn
• mapValues&Std.MultiMap.MultiMap[K, A] -> fn(A) -> B -> Std.MultiMap.MultiMap[K, B]

  Every value transformed, keeping its key and position.

  fn
• merge&Std.MultiMap.MultiMap[K, V] -> &Std.MultiMap.MultiMap[K, V] -> Std.MultiMap.MultiMap[K, V]

  Two maps combined, with the second map's values added after the first's.

  fn
• MultiMap

  A map holding several values under one key.

  type
• pairs&Std.MultiMap.MultiMap[K, V] -> Array[(K, V)]

  Every key paired with each of its values, in key order.

  fn
• remove&Std.MultiMap.MultiMap[K, V] -> K -> V -> Std.MultiMap.MultiMap[K, V]

  The map with one occurrence of a value removed from a key.

  fn
• removeAll&Std.MultiMap.MultiMap[K, V] -> K -> V -> Std.MultiMap.MultiMap[K, V]

  The map with every occurrence of a value removed from a key.

  fn
• removeKey&Std.MultiMap.MultiMap[K, V] -> K -> Std.MultiMap.MultiMap[K, V]

  The map with a key and all its values removed.

  fn
• setAll&Std.MultiMap.MultiMap[K, V] -> K -> &Array[V] -> Std.MultiMap.MultiMap[K, V]

  The map with a key's values replaced entirely.

  fn
• size&Std.MultiMap.MultiMap[K, V] -> Int

  How many keys have values.

  fn
• toMap&Std.MultiMap.MultiMap[K, V] -> Map[K, Array[V]]

  The map as an ordinary map from key to its values.

  fn
• total&Std.MultiMap.MultiMap[K, V] -> Int

  How many values the map holds across every key.

  fn
• values&Std.MultiMap.MultiMap[K, V] -> Array[V]

  Every value under every key, in key order.

  fn