map¶

fun map::by(Sequence: any, Fn₁, : function, ...): map

Returns a map with keys Fnₙ(...(Fn₁(Vᵢ))) and values Vᵢ where Vᵢ are the values produced by Sequence.

map::by("ABCDEFGH", :code)
:> {65 is "A", 66 is "B", 67 is "C", 68 is "D", 69 is "E", 70 is "F", 71 is "G", 72 is "H"}

fun map::to(Sequence: any, Fn₁, : function, ...): map

Returns a map with keys Vᵢ and values Fnₙ(...(Fn₁(Vᵢ))) where Vᵢ are the values produced by Sequence.

map::to("ABCDEFGH", :code)
:> {"A" is 65, "B" is 66, "C" is 67, "D" is 68, "E" is 69, "F" is 70, "G" is 71, "H" is 72}

meth (Key: any):in(Map: map): any | nil

Returns Key if it is in Map, otherwise return nil.

let M := {"A" is 1, "B" is 2, "C" is 3}
"A" in M :> "A"
"D" in M :> nil

type map < sequence

A map of key-value pairs. Keys can be of any type supporting hashing and comparison. By default, iterating over a map generates the key-value pairs in the order they were inserted, however this ordering can be changed.

meth map(Key₁ is Value₁, ...): map

Returns a new map with the specified keys and values.

map(A is 1, B is 2, C is 3)
:> {"A" is 1, "B" is 2, "C" is 3}

meth map(Sequence: sequence, ...): map

Returns a map of all the key and value pairs produced by Sequence.

map("cake") :> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}

meth map(): map

Returns a new map.

map() :> {}

fun map::join(Map₁, : map, ..., Fn: function): map

Returns a new map containing the union of the keys of Mapᵢ, and with values Fn(V₁, ..., Vₙ) where each Vᵢ comes from Mapᵢ (or nil).

let A := map(swap("apple"))
:> {"a" is 1, "p" is 3, "l" is 4, "e" is 5}
let B := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let C := map(swap("pear"))
:> {"p" is 1, "e" is 2, "a" is 3, "r" is 4}
map::join(A, B, C, tuple)
:> {"a" is (1, 6, 3), "p" is (3, nil, 1), "l" is (4, nil, nil), "e" is (5, nil, 2), "b" is (nil, 1, nil), "n" is (nil, 5, nil), "r" is (nil, nil, 4)}

fun map::join2(Map₁, : map, ..., Fn: function): map

Returns a new map containing the union of the keys of Mapᵢ, and with values Fn(K, V₁, ..., Vₙ) where each Vᵢ comes from Mapᵢ (or nil).

let A := map(swap("apple"))
:> {"a" is 1, "p" is 3, "l" is 4, "e" is 5}
let B := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let C := map(swap("pear"))
:> {"p" is 1, "e" is 2, "a" is 3, "r" is 4}
map::join2(A, B, C, tuple)
:> {"a" is (a, 1, 6, 3), "p" is (p, 3, nil, 1), "l" is (l, 4, nil, nil), "e" is (e, 5, nil, 2), "b" is (b, nil, 1, nil), "n" is (n, nil, 5, nil), "r" is (r, nil, nil, 4)}

meth (Map: map) :: (Key: string): map::node

Same as Map[Key]. This method allows maps to be used as modules.

let M := copy({"A" is 1, "B" is 2, "C" is 3}, :const)
M::A :> 1
M::D :> nil

meth (Map₁: map) * (Map₂: map): map

Returns a new map containing the entries of Map₁ which are also in Map₂. The values are chosen from Map₂.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A * B :> {"b" is 1, "a" is 4}

meth (Map: map) * (Set: set): map

Returns a new map containing the entries of Map whose keys are also in Set.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := set("bread") :> {b, r, e, a, d}
A * B :> {"b" is 1, "a" is 6}

meth (Map₁: map) + (Map₂: map): map

Returns a new map combining the entries of Map₁ and Map₂. If the same key is in both Map₁ and Map₂ then the corresponding value from Map₂ is chosen.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A + B
:> {"b" is 1, "a" is 4, "n" is 5, "r" is 2, "e" is 3, "d" is 5}

meth (Map₁: map) / (Map₂: map): map

Returns a new map containing the entries of Map₁ which are not in Map₂.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A / B :> {"n" is 5}

meth (Map: map) / (Set: set): map

Returns a new map containing the entries of Map whose keys are not in Set.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := set("bread") :> {b, r, e, a, d}
A / B :> {"n" is 5}

meth (Map₁: map) /\ (Map₂: map): map

Returns a new map containing the entries of Map₁ which are also in Map₂. The values are chosen from Map₂.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A /\ B :> {"b" is 1, "a" is 4}

meth (Map: map) /\ (Set: set): map

Returns a new map containing the entries of Map whose keys are also in Set.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := set("bread") :> {b, r, e, a, d}
A /\ B :> {"b" is 1, "a" is 6}

meth (Map₁: map) <=> (Map₂: map): map

Returns a tuple of (Map₁ / Map₂, Map₁ * Map₂, Map₂ / Map₁).

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A <=> B
:> ({n is 5}, {b is 1, a is 6}, {r is 2, e is 3, d is 5})

meth (Map₁: map) >< (Map₂: map): map

Returns a new map containing the entries of Map₁ and Map₂ that are not in both.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A >< B :> {"n" is 5, "r" is 2, "e" is 3, "d" is 5}

meth (Map: map)[Key: any]: any | nil

Returns the value corresponding to Key in Map, or nil if Key is not in Map.

let M := copy({"A" is 1, "B" is 2, "C" is 3}, :const)
M["A"] :> 1
M["D"] :> nil

meth (Map₁: map) \/ (Map₂: map): map

Returns a new map combining the entries of Map₁ and Map₂. If the same key is in both Map₁ and Map₂ then the corresponding value from Map₂ is chosen.

let A := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
let B := map(swap("bread"))
:> {"b" is 1, "r" is 2, "e" is 3, "a" is 4, "d" is 5}
A \/ B
:> {"b" is 1, "a" is 4, "n" is 5, "r" is 2, "e" is 3, "d" is 5}

meth (Map: map):backwards: Sequence

Returns a sequence which will iterate over Map backwards.

map(map("abc"):backwards)
:> {3 is "c", 2 is "b", 1 is "a"}

meth (Map: map):count: integer

Returns the number of entries in Map.

{"A" is 1, "B" is 2, "C" is 3}:count :> 3

meth (Map: map):first

Returns the first value in Map or nil if Map is empty.

meth (Map: map):first2

Returns the first key and value in Map or nil if Map is empty.

meth (Map: map):from(Key: any): sequence | nil

Returns the subset of Map after Key as a sequence.

let M := {"A" is 1, "B" is 2, "C" is 3, "D" is 4, "E" is 5}
map(M:from("C")) :> {"C" is 3, "D" is 4, "E" is 5}
map(M:from("F")) :> {}

meth (Map: map):last

Returns the last value in Map or nil if Map is empty.

meth (Map: map):last2

Returns the last key and value in Map or nil if Map is empty.

meth (Map: map):order: map::order

Returns the current ordering of Map.

meth (Map: map):precount: integer

Returns the number of entries in Map.

{"A" is 1, "B" is 2, "C" is 3}:count :> 3

meth (List: map):random: any

Returns a random (assignable) node from Map.

let M := map("cake")
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M:random :> "e"
M:random :> "k"

meth (Map: map):size: integer

Returns the number of entries in Map.

{"A" is 1, "B" is 2, "C" is 3}:size :> 3

meth (Buffer: string::buffer):append(Map: map)

Appends a representation of Map to Buffer.

meth (Buffer: string::buffer):append(Map: map, Sep: string, Conn: string)

Appends the entries of Map to Buffer with Conn between keys and values and Sep between entries.

type map::labeller < function, map

A labeller is a function which returns an incrementing integer for each new unique argument, but returns the previous integer for previously seen arguments.

let Labels := map::labeller() :> {}
Labels("A") :> 1
Labels("B") :> 2
Labels("C") :> 3
Labels("B") :> 2

fun map::labeller(): map::labeller

TBD

type map::mutable < map

TBD

meth (Map: map::mutable) :: (Key: string): map::node

Same as Map[Key]. This method allows maps to be used as modules.

let M := {"A" is 1, "B" is 2, "C" is 3}
M::A :> 1
M::D :> nil
M::A := 10 :> 10
M::D := 20 :> 20
M :> {"A" is 10, "B" is 2, "C" is 3, "D" is 20}

meth (Map: map::mutable)[Key: any]: map::node

Returns the node corresponding to Key in Map. If Key is not in Map then a new floating node is returned with value nil. This node will insert Key into Map if assigned.

let M := {"A" is 1, "B" is 2, "C" is 3}
M["A"] :> 1
M["D"] :> nil
M["A"] := 10 :> 10
M["D"] := 20 :> 20
M :> {"A" is 10, "B" is 2, "C" is 3, "D" is 20}

meth (Map: map::mutable)[Key: any, Fn: function]: map::node

Returns the node corresponding to Key in Map. If Key is not in Map then Fn(Key) is called and the result inserted into Map.

let M := {"A" is 1, "B" is 2, "C" is 3}
M["A", fun(Key) Key:code] :> 1
M["D", fun(Key) Key:code] :> 68
M :> {"A" is 1, "B" is 2, "C" is 3, "D" is 68}

meth (Map: map::mutable):delete(Key: any): any | nil

Removes Key from Map and returns the corresponding value if any, otherwise nil.

let M := {"A" is 1, "B" is 2, "C" is 3}
M:delete("A") :> 1
M:delete("D") :> nil
M :> {"B" is 2, "C" is 3}

meth (Map: map::mutable):empty: map

Deletes all keys and values from Map and returns it.

let M := {"A" is 1, "B" is 2, "C" is 3}
:> {"A" is 1, "B" is 2, "C" is 3}
M:empty :> {}

meth (Map: map::mutable):exists(Key: any, Fn: function): any | nil

If Key is present in Map then returns the corresponding value. Otherwise inserts Key into Map with value Fn(Key) and returns nil.

let M := {"A" is 1, "B" is 2, "C" is 3}
M:exists("A", fun(Key) Key:code) :> 1
M:exists("D", fun(Key) Key:code) :> nil
M :> {"A" is 1, "B" is 2, "C" is 3, "D" is 68}

meth (Map: map::mutable):filter(Filter: function): map

Removes every Value from Map for which Function(Value) returns nil and returns those values in a new map.

let M := map(swap("abcdefghij"))
M:filter(2 | _)
:> {"a" is 1, "c" is 3, "e" is 5, "g" is 7, "i" is 9}
M :> {"b" is 2, "d" is 4, "f" is 6, "h" is 8, "j" is 10}

meth (Map: map::mutable):filter2(Filter: function): map

Removes every Value from Map for which Function(Value) returns nil and returns those values in a new map.

let M := map(swap("abcdefghij"))
M:filter2(fun(K, V) K = "c" or V = 7)
:> {"a" is 1, "b" is 2, "d" is 4, "e" is 5, "f" is 6, "h" is 8, "i" is 9, "j" is 10}
M :> {"c" is 3, "g" is 7}

meth (Arg₁: map::mutable):grow(Arg₂₁ is Value₁, ...)

Deprecated since version 2.15.0: Use :insert instead.

meth (Map: map::mutable):grow(Sequence: sequence, ...): map

Adds of all the key and value pairs produced by Sequence to Map and returns Map.

map("cake"):grow("banana")
:> {1 is "b", 2 is "a", 3 is "n", 4 is "a", 5 is "n", 6 is "a"}

meth (Map: map::mutable):insert(Key: any, Value: any): any | nil

Inserts Key into Map with corresponding value Value. Returns the previous value associated with Key if any, otherwise nil.

let M := {"A" is 1, "B" is 2, "C" is 3}
M:insert("A", 10) :> 1
M:insert("D", 20) :> nil
M :> {"A" is 10, "B" is 2, "C" is 3, "D" is 20}

meth (Map: map::mutable):insert(Key₁ is Value₁, ...): Map

Inserts the pairs Keyᵢ, Valueᵢ into Map. Returns Map.

let M := {"A" is 1, "B" is 2, "C" is 3}
M:insert(A is 10, D is 20)
:> {"A" is 10, "B" is 2, "C" is 3, "D" is 20}

meth (Map: map::mutable):missing(Key: any): some | nil

If Key is present in Map then returns nil. Otherwise inserts Key into Map with value some and returns some.

let M := {"A" is 1, "B" is 2, "C" is 3}
M:missing("A") :> nil
M:missing("D") :> some
M :> {"A" is 1, "B" is 2, "C" is 3, "D"}

meth (Map: map::mutable):missing(Key: any, Fn: function): any | nil

If Key is present in Map then returns nil. Otherwise inserts Key into Map with value Fn(Key) and returns the new value.

let M := {"A" is 1, "B" is 2, "C" is 3}
M:missing("A", fun(Key) Key:code) :> nil
M:missing("D", fun(Key) Key:code) :> 68
M :> {"A" is 1, "B" is 2, "C" is 3, "D" is 68}

meth (Map: map::mutable):order(Order: map::order): map

Sets the ordering

meth (Map: map::mutable):pop: any | nil

Deletes the first key-value pair from Map according to its iteration order. Returns the deleted value, or nil if Map is empty.

:> Insertion order (default)
let M1 := map("cake")
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M1:pop :> "c"
M1 :> {2 is "a", 3 is "k", 4 is "e"}

:> LRU order
let M2 := map("cake"):order(map::order::LRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M2[2]; M2[4]; M2[1]; M2[3]
M2:pop :> "a"
M2 :> {4 is "e", 1 is "c", 3 is "k"}

:> MRU order
let M3 := map("cake"):order(map::order::MRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M3[2]; M3[4]; M3[1]; M3[3]
M3:pop :> "k"
M3 :> {1 is "c", 4 is "e", 2 is "a"}

meth (Map: map::mutable):pop2: tuple[any, any] | nil

Deletes the first key-value pair from Map according to its iteration order. Returns the deleted key-value pair, or nil if Map is empty.

:> Insertion order (default)
let M1 := map("cake")
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M1:pop2 :> (1, c)
M1 :> {2 is "a", 3 is "k", 4 is "e"}

:> LRU order
let M2 := map("cake"):order(map::order::LRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M2[2]; M2[4]; M2[1]; M2[3]
M2:pop2 :> (2, a)
M2 :> {4 is "e", 1 is "c", 3 is "k"}

:> MRU order
let M3 := map("cake"):order(map::order::MRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M3[2]; M3[4]; M3[1]; M3[3]
M3:pop2 :> (3, k)
M3 :> {1 is "c", 4 is "e", 2 is "a"}

meth (Map: map::mutable):pull: any | nil

Deletes the last key-value pair from Map according to its iteration order. Returns the deleted value, or nil if Map is empty.

:> Insertion order (default)
let M1 := map("cake")
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M1:pull :> "e"
M1 :> {1 is "c", 2 is "a", 3 is "k"}

:> LRU order
let M2 := map("cake"):order(map::order::LRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M2[2]; M2[4]; M2[1]; M2[3]
M2:pull :> "k"
M2 :> {2 is "a", 4 is "e", 1 is "c"}

:> MRU order
let M3 := map("cake"):order(map::order::MRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M3[2]; M3[4]; M3[1]; M3[3]
M3:pull :> "a"
M3 :> {3 is "k", 1 is "c", 4 is "e"}

meth (Map: map::mutable):pull2: tuple[any, any] | nil

Deletes the last key-value pair from Map according to its iteration order. Returns the deleted key-value pair, or nil if Map is empty.

:> Insertion order (default)
let M1 := map("cake")
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M1:pull2 :> (4, e)
M1 :> {1 is "c", 2 is "a", 3 is "k"}

:> LRU order
let M2 := map("cake"):order(map::order::LRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M2[2]; M2[4]; M2[1]; M2[3]
M2:pull2 :> (3, k)
M2 :> {2 is "a", 4 is "e", 1 is "c"}

:> MRU order
let M3 := map("cake"):order(map::order::MRU)
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M3[2]; M3[4]; M3[1]; M3[3]
M3:pull2 :> (2, a)
M3 :> {3 is "k", 1 is "c", 4 is "e"}

meth (Map: map::mutable):push(Key: any, Value: any): map

Inserts Key into Map with corresponding value Value.

let M := {"B" is 2, "C" is 3, "A" is 1}:order(map::order::Descending)
M:push("A", 10) :> {"A" is 10, "B" is 2, "C" is 3}
M:push("D", 20)
:> {"D" is 20, "A" is 10, "B" is 2, "C" is 3}
M :> {"D" is 20, "A" is 10, "B" is 2, "C" is 3}

meth (Map: map::mutable):put(Key: any, Value: any): map

Inserts Key into Map with corresponding value Value.

let M := {"B" is 2, "C" is 3, "A" is 1}:order(map::order::Descending)
M:put("A", 10) :> {"B" is 2, "C" is 3, "A" is 10}
M:put("D", 20)
:> {"B" is 2, "C" is 3, "A" is 10, "D" is 20}
M :> {"B" is 2, "C" is 3, "A" is 10, "D" is 20}

meth (Map: map::mutable):remove(Filter: function): map

Removes every Value from Map for which Function(Value) doesn't return nil and returns those values in a new map.

let M := map(swap("abcdefghij"))
M:remove(2 | _)
:> {"b" is 2, "d" is 4, "f" is 6, "h" is 8, "j" is 10}
M :> {"a" is 1, "c" is 3, "e" is 5, "g" is 7, "i" is 9}

meth (Map: map::mutable):remove2(Filter: function): map

Removes every Value from Map for which Function(Value) doesn't return nil and returns those values in a new map.

let M := map(swap("abcdefghij"))
M:remove2(fun(K, V) K = "c" or V = 7)
:> {"c" is 3, "g" is 7}
M
:> {"a" is 1, "b" is 2, "d" is 4, "e" is 5, "f" is 6, "h" is 8, "i" is 9, "j" is 10}

meth (Map: map::mutable):reverse: map

Reverses the iteration order of Map in-place and returns it.

let M := map("cake")
:> {1 is "c", 2 is "a", 3 is "k", 4 is "e"}
M:reverse :> {4 is "e", 3 is "k", 2 is "a", 1 is "c"}

meth (Map: map::mutable):sort: Map

Sorts the entries (changes the iteration order) of Map using Keyᵢ < Keyⱼ and returns Map.

let M := map(swap("cake"))
:> {"c" is 1, "a" is 2, "k" is 3, "e" is 4}
M:sort :> {"a" is 2, "c" is 1, "e" is 4, "k" is 3}

meth (Map: map::mutable):sort(Cmp: function): Map

Sorts the entries (changes the iteration order) of Map using Cmp(Keyᵢ, Keyⱼ) and returns Map

let M := map(swap("cake"))
:> {"c" is 1, "a" is 2, "k" is 3, "e" is 4}
M:sort(>) :> {"k" is 3, "e" is 4, "c" is 1, "a" is 2}

meth (Map: map::mutable):sort(Cmp: method): Map

Sorts the entries (changes the iteration order) of Map using Cmp(Keyᵢ, Keyⱼ) and returns Map

let M := map(swap("cake"))
:> {"c" is 1, "a" is 2, "k" is 3, "e" is 4}
M:sort(>) :> {"k" is 3, "e" is 4, "c" is 1, "a" is 2}

meth (Map: map::mutable):sort2(Cmp: function): Map

Sorts the entries (changes the iteration order) of Map using Cmp(Keyᵢ, Keyⱼ, Valueᵢ, Valueⱼ) and returns Map

let M := map(swap("cake"))
:> {"c" is 1, "a" is 2, "k" is 3, "e" is 4}
M:sort(fun(K1, K2, V1, V2) V1 < V2)
:> {"e" is 4, "k" is 3, "a" is 2, "c" is 1}

meth (Map: map::mutable):splice: map

Removes every key-value pair from Map, returns the removed pairs as a new map.

meth (Map: map::mutable):splice(Key: any): map | nil

Removes every key-value pair from Map starting at Key, returning the removed pairs as a new map. Returns nil if Key is not in Map.

let M := {"A" is 1, "B" is 2, "C" is 3, "D" is 4, "E" is 5, "F" is 6}
M:splice("D") :> {"D" is 4, "E" is 5, "F" is 6}
M :> {"A" is 1, "B" is 2, "C" is 3}

meth (Map: map::mutable):splice(Key: any, Count: integer): map | nil

Removes Count key-value pairs from Map starting at Key, returning the removed pairs as a new map. Returns nil if Key is not in Map or there are not enough pairs to remove.

let M := {"A" is 1, "B" is 2, "C" is 3, "D" is 4, "E" is 5, "F" is 6}
M:splice("C", 2) :> {"C" is 3, "D" is 4}
M :> {"A" is 1, "B" is 2, "E" is 5, "F" is 6}
M:splice("E", 10) :> nil
M :> {"A" is 1, "B" is 2, "E" is 5, "F" is 6}

meth (Map: map::mutable):splice(Count: any, Key: integer, New: map::mutable): map

Removes Count key-value pairs from Map starting at Key, then moves the key-value pairs from New into Map leaving New empty. Returns the removed pairs as a new map, or :nil if Key is not in Map.

let M := {"A" is 1, "B" is 2, "C" is 3, "D" is 4, "E" is 5, "F" is 6}
M:splice("D", 2, {"G" is 7, "H" is 8})
:> {"D" is 4, "E" is 5}
M
:> {"A" is 1, "B" is 2, "C" is 3, "G" is 7, "H" is 8, "F" is 6}

meth (Map: map::mutable):splice(Key: any, New: map::mutable): map

Removes every key-value pair from Map starting at Key, then moves the key-value pairs from New into Map leaving New empty. Returns the removed pairs as a new map, or :nil if Key is not in Map.

let M := {"A" is 1, "B" is 2, "C" is 3, "D" is 4, "E" is 5, "F" is 6}
M:splice("D", {"G" is 7, "H" is 8}) :> {}
M
:> {"A" is 1, "B" is 2, "C" is 3, "G" is 7, "H" is 8, "D" is 4, "E" is 5, "F" is 6}

meth (Map: map::mutable):take(Source: map::mutable): map

Inserts the key-value pairs from Source into Map, leaving Source empty.

let A := map(swap("cat"))
:> {"c" is 1, "a" is 2, "t" is 3}
let B := map(swap("cake"))
:> {"c" is 1, "a" is 2, "k" is 3, "e" is 4}
A:take(B)
:> {"c" is 1, "a" is 2, "t" is 3, "k" is 3, "e" is 4}
A :> {"c" is 1, "a" is 2, "t" is 3, "k" is 3, "e" is 4}
B :> {}

type map::node

A node in a map. Dereferencing a map::node::const returns the corresponding value from the map.

type map::node::mutable < map::node

A node in a map. Dereferencing a map::node returns the corresponding value from the map. Assigning to a map::node updates the corresponding value in the map.

type map::node::mutable

A node in a map. Dereferencing a map::node returns the corresponding value from the map. Assigning to a map::node updates the corresponding value in the map.

type map::order < enum

::Insert - default ordering; inserted pairs are put at end, no reordering on access.
::LRU - inserted pairs are put at start, accessed pairs are moved to start.
::MRU - inserted pairs are put at end, accessed pairs are moved to end.
::Ascending - inserted pairs are kept in ascending key order, no reordering on access.
::Descending - inserted pairs are kept in descending key order, no reordering on access.

fun map::reduce(Sequence: sequence, Reduce: function)

Creates a new map, Map, then applies Map[Key] := Reduce(old, Value) for each Key, Value pair generated by Sequence, finally returning Map.

map::reduce(swap("banana"); L := [], I) L:put(I)
:> {"b" is [1], "a" is [2, 4, 6], "n" is [3, 5]}

meth (Set: set) * (Map: map): map

Returns a new map containing the entries of Map whose keys are also in Set.

let A := set("bread") :> {b, r, e, a, d}
let B := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
A * B :> {"b" is 1, "a" is 6}

meth (Set: set) /\ (Map: map): map

Returns a new map containing the entries of Map whose keys are also in Set.

let A := set("bread") :> {b, r, e, a, d}
let B := map(swap("banana"))
:> {"b" is 1, "a" is 6, "n" is 5}
A /\ B :> {"b" is 1, "a" is 6}

meth (Copy: visitor):const(Map: map): map::const

Returns a new constant map containing copies of the keys and values of Map created using Copy.

meth (Copy: visitor):copy(Map: map): map

Returns a new map contains copies of the keys and values of Map created using Copy.

meth (Copy: visitor):visit(Map: map): map

Returns a new map contains copies of the keys and values of Map created using Copy.