5.4 KiB
Sets
Sets represent an unordered collection of unique elements. These are implemented using hash tables.
a := {10, 20, 30}
b := {20, 30}
>> a:overlap(b)
= {20}
Syntax
Sets are written using {} curly braces with comma-separated items:
nums := {10, 20, 30}
Empty sets must specify the item type explicitly:
empty := {:Int}
For type annotations, a set that holds items with type T is written as {T}.
Comprehensions
Similar to arrays, sets can use comprehensions:
set := {10*i for i in 10}
set2 := {10*i for i in 10 if i mod 2 == 0}
set3 := {-10, 10*i for i in 10}
Accessing Items
Sets internally store their items in an array, which you can access with the
.items field. This is a constant-time operation that produces an immutable
view:
set := {10, 20, 30}
>> set.items
= [10, 20, 30]
Length
Set length can be accessed by the .length field:
>> {10, 20, 30}.length
= 3
Iteration
You can iterate over the items in a table like this:
for item in set:
...
for i, item in set:
...
Set iteration operates over the value of the set when the loop began, so modifying the set during iteration is safe and will not result in the loop iterating over any of the new values.
Set Methods
func add(set:{T}, item: T -> Void)func add_all(set:@{T}, items: [T] -> Void)func clear(set:@{T} -> Void)func has(set:{T}, item:T -> Bool)func (set: {T}, other: {T}, strict: Bool = no -> Bool)func is_superset_of(set:{T}, other: {T}, strict: Bool = no -> Bool)func overlap(set:{T}, other: {T} -> {T})func remove(set:@{T}, item: T -> Void)func remove_all(set:@{T}, items: [T] -> Void)func with(set:{T}, other: {T} -> {T})func without(set:{T}, other: {T} -> {T})
add
Adds an item to the set.
func add(set:{T}, item: T -> Void)
set: The mutable reference to the set.item: The item to add to the set.
Returns:
Nothing.
Example:
>> nums:add(42)
add_all
Adds multiple items to the set.
func add_all(set:@{T}, items: [T] -> Void)
set: The mutable reference to the set.items: The array of items to add to the set.
Returns:
Nothing.
Example:
>> nums:add_all([1, 2, 3])
clear
Removes all items from the set.
func clear(set:@{T} -> Void)
set: The mutable reference to the set.
Returns:
Nothing.
Example:
>> nums:clear()
has
Checks if the set contains a specified item.
func has(set:{T}, item:T -> Bool)
set: The set to check.item: The item to check for presence.
Returns:
yes if the item is present, no otherwise.
Example:
>> {10, 20}:has(20)
= yes
is_subset_of
Checks if the set is a subset of another set.
func (set: {T}, other: {T}, strict: Bool = no -> Bool)
set: The set to check.other: The set to compare against.strict: Ifyes, checks if the set is a strict subset (does not equal the other set).
Returns:
yes if the set is a subset of the other set (strictly or not), no otherwise.
Example:
>> {1, 2}:is_subset_of({1, 2, 3})
= yes
is_superset_of
Checks if the set is a superset of another set.
func is_superset_of(set:{T}, other: {T}, strict: Bool = no -> Bool)
set: The set to check.other: The set to compare against.strict: Ifyes, checks if the set is a strict superset (does not equal the other set).
Returns:
yes if the set is a superset of the other set (strictly or not), no otherwise.
Example:
>> {1, 2, 3}:is_superset_of({1, 2})
= yes
overlap
Creates a new set with items that are in both the original set and another set.
func overlap(set:{T}, other: {T} -> {T})
set: The original set.other: The set to intersect with.
Returns:
A new set containing only items present in both sets.
Example:
>> {1, 2}:overlap({2, 3})
= {2}
remove
Removes an item from the set.
func remove(set:@{T}, item: T -> Void)
set: The mutable reference to the set.item: The item to remove from the set.
Returns:
Nothing.
Example:
>> nums:remove(42)
remove_all
Removes multiple items from the set.
func remove_all(set:@{T}, items: [T] -> Void)
set: The mutable reference to the set.items: The array of items to remove from the set.
Returns:
Nothing.
Example:
>> nums:remove_all([1, 2, 3])
with
Creates a new set that is the union of the original set and another set.
func with(set:{T}, other: {T} -> {T})
set: The original set.other: The set to union with.
Returns:
A new set containing all items from both sets.
Example:
>> {1, 2}:with({2, 3})
= {1, 2, 3}
without
Creates a new set with items from the original set but without items from another set.
func without(set:{T}, other: {T} -> {T})
set: The original set.other: The set of items to remove from the original set.
Returns:
A new set containing items from the original set excluding those in the other set.
Example:
>> {1, 2}:without({2, 3})
= {1}