6.35 Sets🔗ℹ

Immutable sets can be constructed using the syntax {val_expr, ...}, which creates a set containing the values of the val_exprs. More precisely, a use of curly braces with no preceding expression is parsed as an implicit use of the #%braces form.

A set is indexable, and […] after a set expression with an expression for a value checks for membership: the result is a boolean indicating whether the value is in the set. Mutable sets can be updated with a combination of […] and the := operator, where a #false result on the right-hand side of := removes an element from a set, and any other right-hand side result causes the value to be included in the set. (Use ++ to functionally add to an immutable set.) These uses of […] are implemented by #%index. A set can be used as sequence, in which case it supplies its elements in an unspecified order.

ReadableSet matches both mutable and immutable maps, while MutableSet matches mutable maps (created with, for example, the MutableSet constructor).

The Set.by and MutableSet.by annotation variants match only sets that use the hash and equality procedures specified by key_comp.

Static information associated by Set, etc., makes an expression acceptable to for in static mode.

Note that Set{} and Set() produce an empty set while {…} does not, since {} produces an empty map instead.

The Set.by variants create a map that uses the equality and hashing functions specified by key_comp.

> def s = Set{"x", 1, "y", 2}

> s

{1, 2, "x", "y"}

> s["x"]

#true

> s[1]

#true

> s[42]

#false

> Set("x", 1, "y", 2)

{1, 2, "x", "y"}

The Set binding forms match only immutable sets, while ReadableSet forms match both immutable and mutable sets. For ReadableSet, the & set_bind will match a snapshot (in the sense of Set.snapshot) of the rest of the set. The Set.by binding forms match only immutable sets constructed using key_comp.

> def Set{"x", "y"} = {"x", "y"}

> def Set{"x", "y"} = {"x"}

def: value does not satisfy annotation

value: {"x"}

annotation: matching(Set{"x", "y"})

> def Set{"a"} = {"a", "b"}

> def Set{"a", & rst} = {"a", "b", "c"}

> rst

{"b", "c"}

> def Set{"a", val, ...} = {"a", "b", "c"}

> [val, ...]

["b", "c"]

Note that ... and & are not supported for construction mutable sets, only immutable sets.

> def m = MutableSet{"x", 1, "y", 2}

> m

MutableSet{1, 2, "x", "y"}

> m["x"]

#true

> m["x"] := #false

> m

MutableSet{1, 2, "y"}

> m["x"] := #true

> m

MutableSet{1, 2, "x", "y"}

The ReadableSet.empty binding form matches an empty set whether it is mutable or immutable.

Corresponding to the binding forms, Set.empty and ReadableSet.empty are bound to Set{} with approapriate static information.

> Set.empty

Set{}

> match Set()   | Set.empty: "empty set"   | _: #false

"empty set"

> match MutableSet()   | Set.empty: "empty immutable set"   | _: #false

#false

> match MutableSet()   | ReadableSet.empty: "empty set for now"   | _: #false

"empty set for now"

> Set.length({"a", "b"})
2
> Set.length(Set{})
0
> {"a", "b"}.length()
2
> Set{}.length()
0

> {"a", "b"}.get("a")

#true

> {"a", "b"}["a"]

#true

> {1, 2, 3}.append({2, 3}, {3, 4})

{1, 2, 3, 4}

> {1, 2, 3}.union({2, 3}, {3, 4})

{1, 2, 3, 4}

> {1, 2, 3}.intersect({2, 3}, {3, 4})

{3}

> {1, 2, 3}.remove(2)

{1, 3}

> {1, 2, 3}.remove(4)

{1, 2, 3}

> def s = MutableSet{1, 2, 3}

> s.set(1, #false)

> s

MutableSet{2, 3}

> s[1] := #true

> s

MutableSet{1, 2, 3}

> def s = MutableSet{1, 2, 3}

> s.delete(2)

> s

MutableSet{1, 3}

> {1, 2, 3}.to_list(#true)

[1, 2, 3]