• Set Literals
• Iterating
• Containment
• Set Operators
• Comparison Operators
• Methods

A set object, set, is an unordered collection of distinct values.

$set() -> set
$set(arg: iterable) -> set

Creates a new set. If arg is iterable, initializes the new set by iterating over its values.

Alternatively, you can create a set by draining an iterator, e.g.

var set = "supercalifragilistic":runes():to_set();
assert set:count() == 12;

Set Literals

You can create a set using literal syntax, e.g.

var set = {1, 2, 3};

Trailing commas are allowed, e.g.

var set = {
    1,
    2,
    3,
};

Note that the empty literal {} will create an empty map — use $set() to create an empty set.

Iterating

Sets are iterable, e.g.

for item in {1, 2, 3} {
    echo item;
}

Containment

You can check if a set contains an item using the in operator, e.g.

var set = {"foo", "bar", "baz"};

if "foo" in set {
    echo "found";
}

This is equivalent to calling the set's :contains() method.

Set Operators

• The | operator returns the union of two sets, e.g. A | B.
• The & operator returns the intersection of two sets, e.g. A & B.
• The - operator returns the difference of two sets, e.g. A - B.
• The ^ operator returns the symmetric difference of two sets, e.g. A ^ B.

Comparison Operators

• A <= B is true if A is a subset of B.
• A < B is true if A is a proper subset of B.
• A >= B is true if A is a superset of B.
• A > B is true if A is a proper superset of B.

Two sets A and B will compare as equal using the == operator, A == B, if they are set-equivalent, i.e. if they contain the same items in any order.

Methods

:add(item: any)

Adds an item to the set. This is a null operation if the set already contains a member equal to item.

:clear()

Removes all items from the set.

:contains(item: any) -> bool

Returns true if the set contains a member equal to item, otherwise false.

:count() -> i64

Returns the number of items in the set.

:difference(other: set) -> set

Returns a new set containing the difference of the two sets — i.e. the set of all items that are in receiver but not in other.

Equivalent to receiver - other.

:intersection(other: set) -> set

Returns a new set containing the intersection of the two sets — i.e. the set of all items that are in both receiver and other.

Equivalent to receiver & other.

:is_empty() -> bool

Returns true if the set is empty.

:is_equal_to(other: set) -> bool

Returns true if receiver is set-equivalent to other, i.e. if the two sets contain the same items in any order.

Equivalent to receiver == other.

:is_proper_subset_of(other: set) -> bool

Returns true if receiver is a proper subset of other.

Equivalent to receiver < other.

:is_proper_superset_of(other: set) -> bool

Returns true if receiver is a proper superset of other.

Equivalent to receiver > other.

:is_subset_of(other: set) -> bool

Returns true if receiver is a subset of other.

Equivalent to receiver <= other.

:is_superset_of(other: set) -> bool

Returns true if receiver is a superset of other.

Equivalent to receiver >= other.

:remove(item: any)

Removes item from the set. This is a null operation if the set does not contain a member equal to item.

:symmetric_difference(other: set) -> set

Returns a new set containing the symmetric difference of the two sets — i.e. the set of all items that are either in receiver or in other but not both.

Equivalent to receiver ^ other.

:union(other: set) -> set

Returns a new set containing the union of the two sets — i.e. the set of all items that are in either receiver or other.

Equivalent to receiver | other.

:values() -> iter

Returns an iterator over the set's values.