Set

type Set<T> = Types.Set.Set<T>

public func toPure<T>(set : Set<T>, compare : (T, T) -> Order.Order) : PureSet.Set<T>

Convert the mutable set to an immutable, purely functional set.

Example:

import Set "mo:base/Set";
import PureSet "mo:base/pure/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);
  let pureSet = Set.toPure(set, Nat.compare);
  assert(PureSet.contains(pureSet, Nat.compare, 1));
}

Runtime: O(n * log(n)). Space: O(n) retained memory plus garbage, see the note below. where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

Note: Creates O(n * log(n)) temporary objects that will be collected as garbage.

public func fromPure<T>(set : PureSet.Set<T>, compare : (T, T) -> Order.Order) : Set<T>

Convert an immutable, purely functional set to a mutable set.

Example:

import PureSet "mo:base/pure/Set";
import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  var pureSet = PureSet.empty<Nat>();
  pureSet := PureSet.add(pureSet, Nat.compare, 1);
  pureSet := PureSet.add(pureSet, Nat.compare, 2);
  pureSet := PureSet.add(pureSet, Nat.compare, 3);
  let mutableSet = Set.fromPure(pureSet, Nat.compare);
}

Runtime: O(n * log(n)). Space: O(n). where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

public func clone<T>(set : Set<T>) : Set<T>

Create a copy of the mutable set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let originalSet = Set.empty<Nat>();
  Set.add(originalSet, Nat.compare, 1);
  Set.add(originalSet, Nat.compare, 2);
  Set.add(originalSet, Nat.compare, 3);
  let clonedSet = Set.clone(originalSet);
}

Runtime: O(n). Space: O(n). where n denotes the number of elements stored in the set.

public func empty<T>() : Set<T>

Create a new empty mutable set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Debug.print(Nat.toText(Set.size(set))); // prints `0`
}

Runtime: O(1). Space: O(1).

public func singleton<T>(element : T) : Set<T>

Create a new mutable set with a single element.

Example:

import Set "mo:base/Set";
import Debug "mo:base/Debug";

persistent actor {
  let cities = Set.singleton<Text>("Zurich");
  Debug.print(debug_show(Set.size(cities))); // prints `1`
}

Runtime: O(1). Space: O(1).

public func clear<T>(set : Set<T>)

Remove all the elements from the set.

Example:

import Set "mo:base/Set";
import Text "mo:base/Text";
import Debug "mo:base/Debug";

persistent actor {
  let cities = Set.empty<Text>();
  Set.add(cities, Text.compare, "Zurich");
  Set.add(cities, Text.compare, "San Francisco");
  Set.add(cities, Text.compare, "London");
  Debug.print(debug_show(Set.size(cities))); // prints `3`

  Set.clear(cities);
  Debug.print(debug_show(Set.size(cities))); // prints `0`
}

Runtime: O(1). Space: O(1).

public func isEmpty<T>(set : Set<T>) : Bool

Determines whether a set is empty.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  Debug.print(debug_show(Set.isEmpty(set))); // prints `false`
  Set.clear(set);
  Debug.print(debug_show(Set.isEmpty(set))); // prints `true`
}

Runtime: O(1). Space: O(1).

public func size<T>(set : Set<T>) : Nat

Return the number of elements in a set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  Debug.print(Nat.toText(Set.size(set))); // prints `3`
}

Runtime: O(1). Space: O(1).

public func equal<T>(
  set1 : Set<T>,
  set2 : Set<T>,
  compare : (T, T) -> Types.Order
) : Bool

Test whether two imperative sets are equal. Both sets have to be constructed by the same comparison function.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set1 = Set.empty<Nat>();
  Set.add(set1, Nat.compare, 1);
  Set.add(set1, Nat.compare, 2);
  Set.add(set1, Nat.compare, 3);
  let set2 = Set.clone(set1);

  assert Set.equal(set1, set2, Nat.compare);
}

Runtime: O(n). Space: O(1).

public func contains<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  element : T
) : Bool

Tests whether the set contains the provided element.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Bool "mo:base/Bool";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  Debug.print(Bool.toText(Set.contains(set, Nat.compare, 1))); // prints `true`
  Debug.print(Bool.toText(Set.contains(set, Nat.compare, 4))); // prints `false`
}

Runtime: O(log(n)). Space: O(1). where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

public func add<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  element : T
)

Add a new element to a set. No effect if the element already exists in the set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);
}

Runtime: O(log(n)). Space: O(log(n)). where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

public func insert<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  element : T
) : Bool

Insert a new element in the set. Returns true if the element is new, false if the element was already contained in the set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set = Set.empty<Nat>();
  assert Set.insert(set, Nat.compare, 1);
  assert Set.insert(set, Nat.compare, 2);
  assert Set.insert(set, Nat.compare, 3);
  assert not (Set.insert(set, Nat.compare, 3));
}

Runtime: O(log(n)). Space: O(log(n)). where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

public func remove<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  element : T
) : ()

Deletes an element from a set. Returns true if the element was contained in the set, false if not.

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  Set.remove(set, Nat.compare, 1);
  Debug.print(debug_show(Set.contains(set, Nat.compare, 1))); // prints `false`.

  Set.remove(set, Nat.compare, 4);
  Debug.print(debug_show(Set.contains(set, Nat.compare, 4))); // prints `false`.
}

Runtime: O(log(n)). Space: O(log(n)) including garbage, see below. where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

Note: Creates O(log(n)) objects that will be collected as garbage.

public func delete<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  element : T
) : Bool

Deletes an element from a set. Returns true if the element was contained in the set, false if not.

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  assert (Set.delete(set, Nat.compare, 1)); // delete returns true
  Debug.print(debug_show(Set.contains(set, Nat.compare, 1))); // prints `false`.

  assert (not Set.delete(set, Nat.compare, 4)); // delete returns false
  Debug.print(debug_show(Set.contains(set, Nat.compare, 4))); // prints `false`.
}

Runtime: O(log(n)). Space: O(log(n)) including garbage, see below. where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

Note: Creates O(log(n)) objects that will be collected as garbage.

public func max<T>(set : Set<T>) : ?T

Retrieves the maximum element from the set. If the set is empty, returns null.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);
  Debug.print(debug_show(Set.max(set))); // prints `?3`.
}

Runtime: O(log(n)). Space: O(1). where n denotes the number of elements stored in the set.

public func min<T>(set : Set<T>) : ?T

Retrieves the minimum element from the set. If the set is empty, returns null.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);
  Debug.print(debug_show(Set.min(set))); // prints `?1`.
}

Runtime: O(log(n)). Space: O(1). where n denotes the number of elements stored in the set.

public func values<T>(set : Set<T>) : Types.Iter<T>

Returns an iterator over the elements in the set, traversing the elements in the ascending order.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  for (number in Set.values(set)) {
     Debug.print(debug_show(number));
  }
  // prints:
  // `1`
  // `2`
  // `3`
}

Cost of iteration over all elements: Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func reverseValues<T>(set : Set<T>) : Types.Iter<T>

Returns an iterator over the elements in the set, traversing the elements in the descending order.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  for (number in Set.reverseValues(set)) {
     Debug.print(debug_show(number));
  }
  // prints:
  // `3`
  // `2`
  // `1`
}

Cost of iteration over all elements: Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func fromIter<T>(iter : Types.Iter<T>, compare : (T, T) -> Order.Order) : Set<T>

Create a mutable set with the elements obtained from an iterator. Potential duplicate elements in the iterator are ignored, i.e. multiple occurrence of an equal element only occur once in the set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";

persistent actor {
  transient let iterator = Iter.fromArray([3, 1, 2, 1]);
  let set = Set.fromIter<Nat>(iterator, Nat.compare);  // => {1, 2, 3}
}

Runtime: O(n * log(n)). Space: O(n). where n denotes the number of elements returned by the iterator and assuming that the compare function implements an O(1) comparison.

public func isSubset<T>(
  set1 : Set<T>,
  set2 : Set<T>,
  compare : (T, T) -> Order.Order
) : Bool

Test whether set1 is a sub-set of set2, i.e. each element in set1 is also contained in set2. Returns true if both sets are equal.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set1 = Set.fromIter(Iter.fromArray([1, 2]), Nat.compare);
  let set2 = Set.fromIter(Iter.fromArray([0, 1, 2]), Nat.compare);
  Debug.print(debug_show(Set.isSubset(set1, set2, Nat.compare))); // prints `true`.
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements stored in the sets set1 and set2, respectively, and assuming that the compare function implements an O(1) comparison.

public func union<T>(
  set1 : Set<T>,
  set2 : Set<T>,
  compare : (T, T) -> Order.Order
) : Set<T>

Returns a new set that is the union of set1 and set2, i.e. a new set that all the elements that exist in at least on of the two sets. Potential duplicates are ignored, i.e. if the same element occurs in both set1 and set2, it only occurs once in the returned set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set1 = Set.fromIter(Iter.fromArray([1, 2, 3]), Nat.compare);
  let set2 = Set.fromIter(Iter.fromArray([3, 4, 5]), Nat.compare);
  let union = Set.union(set1, set2, Nat.compare);
  Debug.print(debug_show(Iter.toArray(Set.values(union)))); // => [1, 2, 3, 4, 5]
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements stored in the sets set1 and set2, respectively, and assuming that the compare function implements an O(1) comparison.

public func intersection<T>(
  set1 : Set<T>,
  set2 : Set<T>,
  compare : (T, T) -> Order.Order
) : Set<T>

Returns a new set that is the intersection of set1 and set2, i.e. a new set that contains all the elements that exist in both sets.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set1 = Set.fromIter(Iter.fromArray([0, 1, 2]), Nat.compare);
  let set2 = Set.fromIter(Iter.fromArray([1, 2, 3]), Nat.compare);
  let intersection = Set.intersection(set1, set2, Nat.compare);
  Debug.print(debug_show(Iter.toArray(Set.values(intersection)))); // => [1, 2]
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements stored in the sets set1 and set2, respectively, and assuming that the compare function implements an O(1) comparison.

public func difference<T>(
  set1 : Set<T>,
  set2 : Set<T>,
  compare : (T, T) -> Order.Order
) : Set<T>

Returns a new set that is the difference between set1 and set2 (set1 minus set2), i.e. a new set that contains all the elements of set1 that do not exist in set2.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set1 = Set.fromIter(Iter.fromArray([1, 2, 3]), Nat.compare);
  let set2 = Set.fromIter(Iter.fromArray([3, 4, 5]), Nat.compare);
  let difference = Set.difference(set1, set2, Nat.compare);
  Debug.print(debug_show(Iter.toArray(Set.values(difference)))); // => [1, 2]
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements stored in the sets set1 and set2, respectively, and assuming that the compare function implements an O(1) comparison.

public func addAll<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  iter : Types.Iter<T>
)

Adds all elements from iter to the specified set. This is equivalent to Set.union() but modifies the set in place.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.fromIter(Iter.fromArray([1, 2, 3]), Nat.compare);
  let iter = Iter.fromArray([3, 4, 5]);
  Set.addAll(set, Nat.compare, iter);
  Debug.print(debug_show(Iter.toArray(Set.values(set)))); // => [1, 2, 3, 4, 5]
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements in set and iter, respectively, and assuming that the compare function implements an O(1) comparison.

public func deleteAll<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  iter : Types.Iter<T>
) : Bool

Deletes all values in iter from the specified set. Returns true if any value was present in the set, otherwise false. The return value indicates whether the size of the set has changed.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.fromIter(Iter.fromArray([0, 1, 2]), Nat.compare);
  let iter = Iter.fromArray([0, 2]);
  assert Set.deleteAll(set, Nat.compare, iter);
  Debug.print(debug_show(Iter.toArray(Set.values(set)))); // => [1]
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements in set and iter, respectively, and assuming that the compare function implements an O(1) comparison.

public func insertAll<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  iter : Types.Iter<T>
) : Bool

Inserts all values in iter into set. Returns true if any value was not contained in the original set, otherwise false. The return value indicates whether the size of the set has changed.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.fromIter(Iter.fromArray([0, 1, 2]), Nat.compare);
  let iter = Iter.fromArray([0, 2, 3]);
  assert Set.insertAll(set, Nat.compare, iter);
  Debug.print(debug_show(Iter.toArray(Set.values(set)))); // => [0, 1, 2, 3]
}

Runtime: O(m * log(n)). Space: O(1) retained memory plus garbage, see the note below. where m and n denote the number of elements in set and iter, respectively, and assuming that the compare function implements an O(1) comparison.

public func retainAll<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  predicate : T -> Bool
) : Bool

Removes all values in set that do not satisfy the given predicate. Returns true if and only if the size of the set has changed. Modifies the set in place.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);
  Set.retainAll(set, Nat.compare, func (n) { n % 2 == 0 });
  Debug.print(debug_show(Iter.toArray(Set.values(set)))); // => [2]
}

public func forEach<T>(set : Set<T>, operation : T -> ())

Apply an operation on each element contained in the set. The operation is applied in ascending order of the elements.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  Set.forEach<Nat>(set, func (element) {
    Debug.print("element=" # Nat.toText(element));
  })
}

Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func filter<T>(
  set : Set<T>,
  compare : (T, T) -> Order.Order,
  criterion : T -> Bool
) : Set<T>

Filter elements in a new set. Create a copy of the mutable set that only contains the elements that fulfil the criterion function.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let numbers = Set.empty<Nat>();
  Set.add(numbers, Nat.compare, 1);
  Set.add(numbers, Nat.compare, 2);
  Set.add(numbers, Nat.compare, 3);

  let evenNumbers = Set.filter<Nat>(numbers, Nat.compare, func (number) {
    number % 2 == 0
  });
}

Runtime: O(n). Space: O(n). where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

public func map<T1, T2>(
  set : Set<T1>,
  compare : (T2, T2) -> Order.Order,
  project : T1 -> T2
) : Set<T2>

Project all elements of the set in a new set. Apply a mapping function to each element in the set and collect the mapped elements in a new mutable set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Text "mo:base/Text";
import Debug "mo:base/Debug";

persistent actor {
  let numbers = Set.empty<Nat>();
  Set.add(numbers, Nat.compare, 1);
  Set.add(numbers, Nat.compare, 2);
  Set.add(numbers, Nat.compare, 3);

  let textNumbers = Set.map<Nat, Text>(numbers, Text.compare, func (number) {
    Nat.toText(number)
  });
  for (textNumbers in Set.values(textNumbers)) {
     Debug.print(debug_show(textNumbers));
  }
  // prints:
  // `"1"`
  // `"2"`
  // `"3"`
}

Runtime: O(n * log(n)). Space: O(n) retained memory plus garbage, see below. where n denotes the number of elements stored in the set and assuming that the compare function implements an O(1) comparison.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func filterMap<T1, T2>(
  set : Set<T1>,
  compare : (T2, T2) -> Order.Order,
  project : T1 -> ?T2
) : Set<T2>

Filter all elements in the set by also applying a projection to the elements. Apply a mapping function project to all elements in the set and collect all elements, for which the function returns a non-null new element. Collect all non-discarded new elements in a new mutable set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Text "mo:base/Text";
import Debug "mo:base/Debug";

persistent actor {
  let numbers = Set.empty<Nat>();
  Set.add(numbers, Nat.compare, 0);
  Set.add(numbers, Nat.compare, 1);
  Set.add(numbers, Nat.compare, 2);
  Set.add(numbers, Nat.compare, 3);

  let evenTextNumbers = Set.filterMap<Nat, Text>(numbers, Text.compare, func (number) {
    if (number % 2 == 0) {
       ?Nat.toText(number)
    } else {
       null // discard odd numbers
    }
  });
  for (textNumber in Set.values(evenTextNumbers)) {
     Debug.print(textNumber);
  }
  // prints:
  // `"0"`
  // `"2"`
}

Runtime: O(n * log(n)). Space: O(n) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func foldLeft<T, A>(
  set : Set<T>,
  base : A,
  combine : (A, T) -> A
) : A

Iterate all elements in ascending order, and accumulate the elements by applying the combine function, starting from a base value.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  let text = Set.foldLeft<Nat, Text>(
     set,
     "",
     func (accumulator, element) {
       let separator = if (accumulator != "") { ", " } else { "" };
       accumulator # separator # Nat.toText(element)
     }
  );
  Debug.print(text);
  // prints `1, 2, 3`.
}

Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func foldRight<T, A>(
  set : Set<T>,
  base : A,
  combine : (T, A) -> A
) : A

Iterate all elements in descending order, and accumulate the elements by applying the combine function, starting from a base value.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Debug "mo:base/Debug";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  let text = Set.foldRight<Nat, Text>(
     set,
     "",
     func (element, accumulator) {
       let separator = if (accumulator != "") { ", " } else { "" };
       accumulator # separator # Nat.toText(element)
     }
  );
  Debug.print(text);
  // prints `2, 1, 0`
}

Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func join<T>(setIterator : Types.Iter<Set<T>>, compare : (T, T) -> Order.Order) : Set<T>

Construct the union of a series of sets, i.e. all elements of each set are included in the result set. Any duplicates are ignored, i.e. if an element occurs in several of the iterated sets, it only occurs once in the result set.

Assumes all sets are ordered by compare.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  let set1 = Set.fromIter(Iter.fromArray([1, 2, 3]), Nat.compare);
  let set2 = Set.fromIter(Iter.fromArray([3, 4, 5]), Nat.compare);
  let set3 = Set.fromIter(Iter.fromArray([5, 6, 7]), Nat.compare);
  transient let iterator = Iter.fromArray([set1, set2, set3]);
  let combined = Set.join(iterator, Nat.compare);
  Debug.print(debug_show(Iter.toArray(Set.values(combined))));
  // prints: `[1, 2, 3, 4, 5, 6, 7]`.
}

Runtime: O(n * log(n)). Space: O(1) retained memory plus garbage, see the note below. where n denotes the number of elements stored in the iterated sets, and assuming that the compare function implements an O(1) comparison.

public func flatten<T>(setOfSets : Set<Set<T>>, compare : (T, T) -> Order.Order) : Set<T>

Construct the union of a set of element sets, i.e. all elements of each element set are included in the result set. Any duplicates are ignored, i.e. if the same element occurs in multiple element sets, it only occurs once in the result set.

Assumes all sets are ordered by compare.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Order "mo:base/Order";
import Iter "mo:base/Iter";
import Debug "mo:base/Debug";

persistent actor {
  func setCompare(first: Set.Set<Nat>, second: Set.Set<Nat>) : Order.Order {
     Set.compare(first, second, Nat.compare)
  };

  let subSet1 = Set.fromIter(Iter.fromArray([1, 2, 3]), Nat.compare);
  let subSet2 = Set.fromIter(Iter.fromArray([3, 4, 5]), Nat.compare);
  let subSet3 = Set.fromIter(Iter.fromArray([5, 6, 7]), Nat.compare);
  let setOfSets = Set.fromIter(Iter.fromArray([subSet1, subSet2, subSet3]), setCompare);
  let flatSet = Set.flatten(setOfSets, Nat.compare);
  Debug.print(debug_show(Iter.toArray(Set.values(flatSet))));
  // prints: `[1, 2, 3, 4, 5, 6, 7]`.
}

Runtime: O(n * log(n)). Space: O(1) retained memory plus garbage, see the note below. where n denotes the number of elements stored in all the sub-sets, and assuming that the compare function implements an O(1) comparison.

public func all<T>(set : Set<T>, predicate : T -> Bool) : Bool

Check whether all elements in the set satisfy a predicate, i.e. the predicate function returns true for all elements in the set. Returns true for an empty set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  let belowTen = Set.all<Nat>(set, func (number) {
    number < 10
  }); // `true`
}

Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func any<T>(set : Set<T>, predicate : T -> Bool) : Bool

Check whether at least one element in the set satisfies a predicate, i.e. the predicate function returns true for at least one element in the set. Returns false for an empty set.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  let aboveTen = Set.any<Nat>(set, func (number) {
    number > 10
  }); // `false`
}

Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set.

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func assertValid<T>(set : Set<T>, compare : (T, T) -> Order.Order)

Internal sanity check function. Can be used to check that elements have been inserted with a consistent comparison function. Traps if the internal set structure is invalid.

public func toText<T>(set : Set<T>, elementFormat : T -> Text) : Text

Generate a textual representation of all the elements in the set. Primarily to be used for testing and debugging. The elements are formatted according to elementFormat.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";

persistent actor {
  let set = Set.empty<Nat>();
  Set.add(set, Nat.compare, 1);
  Set.add(set, Nat.compare, 2);
  Set.add(set, Nat.compare, 3);

  let text = Set.toText<Nat>(set, Nat.toText);
  // `"{0, 1, 2}"`
}

Runtime: O(n). Space: O(n) retained memory plus garbage, see below. where n denotes the number of elements stored in the set and assuming that elementFormat has runtime and space costs of O(1).

Note: Creates O(log(n)) temporary objects that will be collected as garbage.

public func compare<T>(
  set1 : Set<T>,
  set2 : Set<T>,
  compare : (T, T) -> Order.Order
) : Order.Order

Compare two sets by comparing the elements. Both sets must have been created by the same comparison function. The two sets are iterated by the ascending order of their creation and order is determined by the following rules: Less: set1 is less than set2 if:

• the pairwise iteration hits an element pair element1 and element2 where element1 is less than element2 and all preceding elements are equal, or,
• set1 is a strict prefix of set2, i.e. set2 has more elements than set1 and all elements of set1 occur at the beginning of iteration set2. Equal: set1 and set2 have same series of equal elements by pairwise iteration. Greater: set1 is neither less nor equal set2.

Example:

import Set "mo:base/Set";
import Nat "mo:base/Nat";
import Text "mo:base/Text";

persistent actor {
  let set1 = Set.empty<Nat>();
  Set.add(set1, Nat.compare, 0);
  Set.add(set1, Nat.compare, 1);

  let set2 = Set.empty<Nat>();
  Set.add(set2, Nat.compare, 0);
  Set.add(set2, Nat.compare, 2);

  let orderLess = Set.compare(set1, set2, Nat.compare);
  // `#less`
  let orderEqual = Set.compare(set1, set1, Nat.compare);
  // `#equal`
  let orderGreater = Set.compare(set2, set1, Nat.compare);
  // `#greater`
}

Runtime: O(n). Space: O(1) retained memory plus garbage, see below. where n denotes the number of elements stored in the set and assuming that compare has runtime and space costs of O(1).

Note: Creates O(log(n)) temporary objects that will be collected as garbage.