map

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) + (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) /\ (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) <=> (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):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):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):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 :> "c"
M:random :> "e"
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::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 (Arg₁: map::mutable):grow(Arg₂₁ is Value₁, ...)

TBD

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):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 some.

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) :> some
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):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):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):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

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 < 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::order < enum
  • ::Insert - default ordering; inserted pairs are put at end, no reordering on access.

  • ::LRU - inserted pairs are kept in ascending key order, no reordering on access.

  • ::MRU - inserted pairs are kept in descending key order, no reordering on access.

  • ::Ascending - inserted pairs are put at start, accessed pairs are moved to start.

  • ::Descending - inserted pairs are put at end, accessed pairs are moved to end.

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 (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.