Tuples

Contains modules for working with tuples of different sizes.

Usage example:

import { Tuple2; Tuple3 } "mo:base/Tuples";
import Bool "mo:base/Bool";
import Nat "mo:base/Nat";

let swapped = Tuple2.swap((1, "hello"));
assert swapped == ("hello", 1);
let text = Tuple3.toText((1, true, 3), Nat.toText, Bool.toText, Nat.toText);
assert text == "(1, true, 3)";

module Tuple2

public func swap<A, B>() : (B, A)

Swaps the elements of a tuple.

import { Tuple2 } "mo:base/Tuples";

assert Tuple2.swap((1, "hello")) == ("hello", 1);

public func toText<A, B>(
  t : (A, B),
  toTextA : A -> Text,
  toTextB : B -> Text
) : Text

Creates a textual representation of a tuple for debugging purposes.

import { Tuple2 } "mo:base/Tuples";

import Nat "mo:base/Nat";
assert Tuple2.toText((1, "hello"), Nat.toText, func (x: Text): Text = x) == "(1, hello)";

public func equal<A, B>(
  t1 : (A, B),
  t2 : (A, B),
  aEqual : (A, A) -> Bool,
  bEqual : (B, B) -> Bool
) : Bool

Compares two tuples for equality.

import { Tuple2 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
assert Tuple2.equal((1, "hello"), (1, "hello"), Nat.equal, Text.equal);

public func compare<A, B>(
  t1 : (A, B),
  t2 : (A, B),
  aCompare : (A, A) -> Types.Order,
  bCompare : (B, B) -> Types.Order
) : Types.Order

Compares two tuples lexicographically.

import { Tuple2 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
assert Tuple2.compare((1, "hello"), (1, "world"), Nat.compare, Text.compare) == #less;
assert Tuple2.compare((1, "hello"), (2, "hello"), Nat.compare, Text.compare) == #less;
assert Tuple2.compare((1, "hello"), (1, "hello"), Nat.compare, Text.compare) == #equal;
assert Tuple2.compare((2, "hello"), (1, "hello"), Nat.compare, Text.compare) == #greater;
assert Tuple2.compare((1, "world"), (1, "hello"), Nat.compare, Text.compare) == #greater;

public func makeToText<A, B>(toTextA : A -> Text, toTextB : B -> Text) : ((A, B)) -> Text

Creates a toText function for a tuple given toText functions for its elements. This is useful when you need to reuse the same toText conversion multiple times.

import { Tuple2 } "mo:base/Tuples";
import Nat "mo:base/Nat";

let tupleToText = Tuple2.makeToText<Nat, Text>(Nat.toText, func x = x);
assert tupleToText((1, "hello")) == "(1, hello)";

public func makeEqual<A, B>(aEqual : (A, A) -> Bool, bEqual : (B, B) -> Bool) : ((A, B), (A, B)) -> Bool

Creates an equal function for a tuple given equal functions for its elements. This is useful when you need to reuse the same equality comparison multiple times.

import { Tuple2 } "mo:base/Tuples";
import Nat "mo:base/Nat";
import Text "mo:base/Text";

let tupleEqual = Tuple2.makeEqual(Nat.equal, Text.equal);
assert tupleEqual((1, "hello"), (1, "hello"));

public func makeCompare<A, B>(aCompare : (A, A) -> Types.Order, bCompare : (B, B) -> Types.Order) : ((A, B), (A, B)) -> Types.Order

Creates a compare function for a tuple given compare functions for its elements. This is useful when you need to reuse the same comparison multiple times.

import { Tuple2 } "mo:base/Tuples";
import Nat "mo:base/Nat";
import Text "mo:base/Text";

let tupleCompare = Tuple2.makeCompare(Nat.compare, Text.compare);
assert tupleCompare((1, "hello"), (1, "world")) == #less;

module Tuple3

public func toText<A, B, C>(
  t : (A, B, C),
  toTextA : A -> Text,
  toTextB : B -> Text,
  toTextC : C -> Text
) : Text

Creates a textual representation of a 3-tuple for debugging purposes.

import { Tuple3 } "mo:base/Tuples";

import Nat "mo:base/Nat";
assert Tuple3.toText((1, "hello", 2), Nat.toText, func (x: Text): Text = x, Nat.toText) == "(1, hello, 2)";

public func equal<A, B, C>(
  t1 : (A, B, C),
  t2 : (A, B, C),
  aEqual : (A, A) -> Bool,
  bEqual : (B, B) -> Bool,
  cEqual : (C, C) -> Bool
) : Bool

Compares two 3-tuples for equality.

import { Tuple3 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
assert Tuple3.equal((1, "hello", 2), (1, "hello", 2), Nat.equal, Text.equal, Nat.equal);

public func compare<A, B, C>(
  t1 : (A, B, C),
  t2 : (A, B, C),
  aCompare : (A, A) -> Types.Order,
  bCompare : (B, B) -> Types.Order,
  cCompare : (C, C) -> Types.Order
) : Types.Order

Compares two 3-tuples lexicographically.

import { Tuple3 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
assert Tuple3.compare((1, "hello", 2), (1, "world", 1), Nat.compare, Text.compare, Nat.compare) == #less;
assert Tuple3.compare((1, "hello", 2), (2, "hello", 2), Nat.compare, Text.compare, Nat.compare) == #less;
assert Tuple3.compare((1, "hello", 2), (1, "hello", 2), Nat.compare, Text.compare, Nat.compare) == #equal;
assert Tuple3.compare((2, "hello", 2), (1, "hello", 2), Nat.compare, Text.compare, Nat.compare) == #greater;

public func makeToText<A, B, C>(
  toTextA : A -> Text,
  toTextB : B -> Text,
  toTextC : C -> Text
) : ((A, B, C)) -> Text

Creates a toText function for a 3-tuple given toText functions for its elements. This is useful when you need to reuse the same toText conversion multiple times.

import { Tuple3 } "mo:base/Tuples";

import Nat "mo:base/Nat";
let toText = Tuple3.makeToText<Nat, Text, Nat>(Nat.toText, func x = x, Nat.toText);
assert toText((1, "hello", 2)) == "(1, hello, 2)";

public func makeEqual<A, B, C>(
  aEqual : (A, A) -> Bool,
  bEqual : (B, B) -> Bool,
  cEqual : (C, C) -> Bool
) : ((A, B, C), (A, B, C)) -> Bool

Creates an equal function for a 3-tuple given equal functions for its elements. This is useful when you need to reuse the same equality comparison multiple times.

import { Tuple3 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
let equal = Tuple3.makeEqual(Nat.equal, Text.equal, Nat.equal);
assert equal((1, "hello", 2), (1, "hello", 2));

public func makeCompare<A, B, C>(
  aCompare : (A, A) -> Types.Order,
  bCompare : (B, B) -> Types.Order,
  cCompare : (C, C) -> Types.Order
) : ((A, B, C), (A, B, C)) -> Types.Order

Creates a compare function for a 3-tuple given compare functions for its elements. This is useful when you need to reuse the same comparison multiple times.

import { Tuple3 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
let compare = Tuple3.makeCompare(Nat.compare, Text.compare, Nat.compare);
assert compare((1, "hello", 2), (1, "world", 1)) == #less;

module Tuple4

public func toText<A, B, C, D>(
  t : (A, B, C, D),
  toTextA : A -> Text,
  toTextB : B -> Text,
  toTextC : C -> Text,
  toTextD : D -> Text
) : Text

Creates a textual representation of a 4-tuple for debugging purposes.

import { Tuple4 } "mo:base/Tuples";

import Nat "mo:base/Nat";
assert Tuple4.toText((1, "hello", 2, 3), Nat.toText, func (x: Text): Text = x, Nat.toText, Nat.toText) == "(1, hello, 2, 3)";

public func equal<A, B, C, D>(
  t1 : (A, B, C, D),
  t2 : (A, B, C, D),
  aEqual : (A, A) -> Bool,
  bEqual : (B, B) -> Bool,
  cEqual : (C, C) -> Bool,
  dEqual : (D, D) -> Bool
) : Bool

Compares two 4-tuples for equality.

import { Tuple4 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
assert Tuple4.equal((1, "hello", 2, 3), (1, "hello", 2, 3), Nat.equal, Text.equal, Nat.equal, Nat.equal);

public func compare<A, B, C, D>(
  t1 : (A, B, C, D),
  t2 : (A, B, C, D),
  aCompare : (A, A) -> Types.Order,
  bCompare : (B, B) -> Types.Order,
  cCompare : (C, C) -> Types.Order,
  dCompare : (D, D) -> Types.Order
) : Types.Order

Compares two 4-tuples lexicographically.

import { Tuple4 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
assert Tuple4.compare((1, "hello", 2, 3), (1, "world", 1, 3), Nat.compare, Text.compare, Nat.compare, Nat.compare) == #less;
assert Tuple4.compare((1, "hello", 2, 3), (2, "hello", 2, 3), Nat.compare, Text.compare, Nat.compare, Nat.compare) == #less;
assert Tuple4.compare((1, "hello", 2, 3), (1, "hello", 2, 3), Nat.compare, Text.compare, Nat.compare, Nat.compare) == #equal;
assert Tuple4.compare((2, "hello", 2, 3), (1, "hello", 2, 3), Nat.compare, Text.compare, Nat.compare, Nat.compare) == #greater;

public func makeToText<A, B, C, D>(
  toTextA : A -> Text,
  toTextB : B -> Text,
  toTextC : C -> Text,
  toTextD : D -> Text
) : ((A, B, C, D)) -> Text

Creates a toText function for a 4-tuple given toText functions for its elements. This is useful when you need to reuse the same toText conversion multiple times.

import { Tuple4 } "mo:base/Tuples";

import Nat "mo:base/Nat";
let toText = Tuple4.makeToText(Nat.toText, func (x: Text): Text = x, Nat.toText, Nat.toText);
assert toText((1, "hello", 2, 3)) == "(1, hello, 2, 3)";

public func makeEqual<A, B, C, D>(
  aEqual : (A, A) -> Bool,
  bEqual : (B, B) -> Bool,
  cEqual : (C, C) -> Bool,
  dEqual : (D, D) -> Bool
) : ((A, B, C, D), (A, B, C, D)) -> Bool

Creates an equal function for a 4-tuple given equal functions for its elements. This is useful when you need to reuse the same equality comparison multiple times.

import { Tuple4 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
let equal = Tuple4.makeEqual(Nat.equal, Text.equal, Nat.equal, Nat.equal);
assert equal((1, "hello", 2, 3), (1, "hello", 2, 3));

public func makeCompare<A, B, C, D>(
  aCompare : (A, A) -> Types.Order,
  bCompare : (B, B) -> Types.Order,
  cCompare : (C, C) -> Types.Order,
  dCompare : (D, D) -> Types.Order
) : ((A, B, C, D), (A, B, C, D)) -> Types.Order

Creates a compare function for a 4-tuple given compare functions for its elements. This is useful when you need to reuse the same comparison multiple times.

import { Tuple4 } "mo:base/Tuples";

import Nat "mo:base/Nat";
import Text "mo:base/Text";
let compare = Tuple4.makeCompare(Nat.compare, Text.compare, Nat.compare, Nat.compare);
assert compare((1, "hello", 2, 3), (1, "world", 1, 3)) == #less;