Std.Map

47 public declarations

• adjust&Map[K, V] -> K -> fn(V) -> V -> Map[K, V]

  An entry's value transformed, or the map unchanged when the key has none.

  fn
• all&Map[K, V] -> fn(K, V) -> Bool -> Bool

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

  fn
• alter&Map[K, V] -> K -> fn(Option[V]) -> Option[V] -> Map[K, V]

  An entry inserted, replaced, or removed by one transformation.

  fn
• any&Map[K, V] -> fn(K, V) -> Bool -> Bool

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

  fn
• containsKey&Map[K, V] -> K -> Bool

  Whether a key has an entry.

  fn
• countValues&Map[K, V] -> fn(V) -> Bool -> Int

  How many values the predicate accepts.

  fn
• emptyMap[K, V]

  A map with no entries.

  fn
• filterKeys&Map[K, V] -> fn(K) -> Bool -> Map[K, V]

  Only the entries whose key the predicate accepts.

  fn
• filterValues&Map[K, V] -> fn(V) -> Bool -> Map[K, V]

  Only the entries whose value the predicate accepts.

  fn
• findKey&Map[K, V] -> fn(V) -> Bool -> Option[K]

  The first key whose value the predicate accepts, or `None`.

  fn
• fold&Map[K, V] -> fn(A, K, V) -> A -> A -> A

  Every entry combined into one value, in key order.

  fn
• fromPairs&Array[(K, V)] -> Map[K, V]

  A map built from key and value pairs.

  fn
• fromPairsWith&Array[(K, V)] -> fn(V, V) -> V -> Map[K, V]

  A map built from pairs, with a rule for keys that appear more than once.

  fn
• get&Map[K, V] -> K -> Option[V]

  The value stored under a key, or `None`.

  fn
• getOr&Map[K, V] -> K -> V -> V

  The value stored under a key, or a fallback.

  fn
• greatest&Map[K, V] -> Option[(K, V)]

  The largest key and its value, or `None` for an empty map.

  fn
• groupBy&Array[T] -> fn(T) -> K -> Map[K, Array[T]]

  Items collected under the key each one produces.

  fn
• insert&Map[K, V] -> K -> V -> Map[K, V]

  The map with an entry added or replaced.

  fn
• insertIfAbsent&Map[K, V] -> K -> V -> Map[K, V]

  An entry added only when its key has none.

  fn
• intersectWith&Map[K, V] -> &Map[K, V] -> fn(V, V) -> V -> Map[K, V]

  Only the keys both maps have, with their values combined.

  fn
• invert&Map[K, V] -> Map[V, K]

  The map with its keys and values exchanged.

  fn
• isEmpty&Map[K, V] -> Bool

  Whether the map has no entries.

  fn
• keys&Map[K, V] -> Array[K]

  Every key, in order.

  fn
• keySet&Map[K, V] -> Set[K]

  The keys as a set.

  fn
• keysNotIn&Map[K, V] -> &Map[K, V] -> Array[K]

  The keys of one map that the other does not have.

  fn
• least&Map[K, V] -> Option[(K, V)]

  The smallest key and its value, or `None` for an empty map.

  fn
• mapKeys&Map[K, V] -> fn(K) -> L -> Map[L, V]

  Every key transformed. A transformation that sends two keys to one keeps the

  fn
• mapValues&Map[K, A] -> fn(A) -> B -> Map[K, B]

  Every value transformed.

  fn
• merge&Map[K, V] -> &Map[K, V] -> Map[K, V]

  Two maps combined, with the second map's entries winning.

  fn
• mergeAll&Array[Map[K, V]] -> Map[K, V]

  Every map combined in order, with later maps' entries winning.

  fn
• mergeWith&Map[K, V] -> &Map[K, V] -> fn(V, V) -> V -> Map[K, V]

  Two maps combined, with a caller-supplied rule for keys in both.

  fn
• notContainsKey&Map[K, V] -> K -> Bool

  Whether a key has no entry.

  fn
• pairs&Map[K, V] -> Array[(K, V)]

  Every entry as a pair, in key order.

  fn
• partition&Map[K, V] -> fn(K, V) -> Bool -> (Map[K, V], Map[K, V])

  The entries the predicate accepts, and the entries it rejects.

  fn
• remove&Map[K, V] -> K -> Map[K, V]

  The map with a key's entry removed, or unchanged when there is none.

  fn
• removeGreatest&Map[K, V] -> Map[K, V]

  The map without its largest key.

  fn
• removeLeast&Map[K, V] -> Map[K, V]

  The map without its smallest key.

  fn
• restrictTo&Map[K, V] -> &Array[K] -> Map[K, V]

  Only the keys the given array names.

  fn
• singletonK -> V -> Map[K, V]

  A map with one entry.

  fn
• size&Map[K, V] -> Int

  The number of entries.

  fn
• tally&Array[T] -> Map[T, Int]

  How many times each value appears in an array.

  fn
• toArray&Map[K, V] -> Array[(K, V)]

  The entries as an array, in key order.

  fn
• update&Map[K, V] -> K -> fn(V) -> Option[V] -> Map[K, V]

  An entry's value transformed, removing the entry when the result is absent.

  fn
• upsert&Map[K, V] -> K -> V -> fn(V) -> V -> Map[K, V]

  An entry's value transformed, inserting a starting value when it is absent.

  fn
• values&Map[K, V] -> Array[V]

  Every value, in the order of its key.

  fn
• without&Map[K, V] -> &Map[K, V] -> Map[K, V]

  Only the keys the first map has and the second does not.

  fn
• withoutKeys&Map[K, V] -> &Array[K] -> Map[K, V]

  Every key the given array does not name.

  fn