Std.HashMap

23 public declarations

• bucketCount&Std.HashMap.HashMap[K, V] -> Int where K: Eq + Hash

  How many buckets the map is currently spread across.

  fn
• containsKey&Std.HashMap.HashMap[K, V] -> &K -> Bool where K: Eq + Hash

  Whether a key is present.

  fn
• emptyStd.HashMap.HashMap[K, V] where K: Eq + Hash

  A map holding nothing.

  fn
• entries&Std.HashMap.HashMap[K, V] -> Array[(K, V)] where K: Eq + Hash

  Every pairing, in the order the keys were first put in.

  fn
• Entry

  One pairing, with the position it was first put in.

  type
• equals&Std.HashMap.HashMap[K, V] -> &Std.HashMap.HashMap[K, V] -> Bool where K: Eq + Hash, V: Eq

  Whether two maps hold the same pairings.

  fn
• filter&Std.HashMap.HashMap[K, V] -> fn(K, V) -> Bool -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  A map holding only the pairings a test accepts.

  fn
• fold&Std.HashMap.HashMap[K, V] -> A -> fn(A, K, V) -> A -> A where K: Eq + Hash

  Every pairing combined into one value, in insertion order.

  fn
• fromArray&Array[(K, V)] -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  A map built from pairings, later ones replacing earlier ones.

  fn
• get&Std.HashMap.HashMap[K, V] -> &K -> Option[V] where K: Eq + Hash

  The value under a key, or nothing when the map does not hold it.

  fn
• getOr&Std.HashMap.HashMap[K, V] -> &K -> V -> V where K: Eq + Hash

  The value under a key, or a fallback when the map does not hold it.

  fn
• HashMap

  A map that finds a key by hashing it rather than by comparing it.

  type
• insert&Std.HashMap.HashMap[K, V] -> K -> V -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  A map with a pairing added, replacing any value already under the key.

  fn
• insertWith&Std.HashMap.HashMap[K, V] -> K -> V -> fn(V, V) -> V -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  A map with a pairing added, combining with any value already there.

  fn
• isEmpty&Std.HashMap.HashMap[K, V] -> Bool where K: Eq + Hash

  Whether a map holds nothing.

  fn
• keys&Std.HashMap.HashMap[K, V] -> Array[K] where K: Eq + Hash

  Every key, in the order they were first put in.

  fn
• map&Std.HashMap.HashMap[K, V] -> fn(V) -> W -> Std.HashMap.HashMap[K, W] where K: Eq + Hash

  A map with every value transformed, keeping keys and their order.

  fn
• merge&Std.HashMap.HashMap[K, V] -> &Std.HashMap.HashMap[K, V] -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  Two maps joined, the second's value winning where both hold a key.

  fn
• mergeWith&Std.HashMap.HashMap[K, V] -> &Std.HashMap.HashMap[K, V] -> fn(V, V) -> V -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  Two maps joined, a rule deciding where both hold a key.

  fn
• remove&Std.HashMap.HashMap[K, V] -> &K -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  A map with a key removed, or the same map when it held none.

  fn
• singletonK -> V -> Std.HashMap.HashMap[K, V] where K: Eq + Hash

  A map holding one pairing.

  fn
• size&Std.HashMap.HashMap[K, V] -> Int where K: Eq + Hash

  How many pairings a map holds.

  fn
• values&Std.HashMap.HashMap[K, V] -> Array[V] where K: Eq + Hash

  Every value, in the order their keys were first put in.

  fn