Base

Returns the length of sized.

If sized is a string, the length is the number of characters (more specifically, the number of unicode codepoints).

If sized is a list or set, the length is the number of elements.

If sized is a map, the length is the number of key-value pairs.

assert length("abc") == 3
assert length("") == 0
assert length(['a', 'b']) == 2
assert length([]) == 0
assert length(#[3.7]) == 1
assert length(#[]) == 0
assert length({ true => @hi, false => @hey }) == 2
assert length({}) == 0

Returns whether sized is empty. "" is an empty string, [] is an empty list, #[] is an empty set, and {} is an empty map. This is equivalent to when length() returns 0, but avoids computing the full length in various cases.

assert !empty?("abc")
assert empty?("")
assert !empty?(['a', 'b'])
assert empty?([])
assert !empty?(#[3.7])
assert empty?(#[])
assert !empty?({ true => @hi, false => @hey })
assert empty?({})

Concatenates a and b together, equivalent to a ++ b.

For strings and lists, the result contains the characters/elements of a followed by the characters/elements of b.

For sets, merges (unions) a and b together, returning a new set.

For maps, merges a and b together, returning a new map. If a key exists in both a and b, the value in b takes precedence.

assert concat("hello ", "world") == "hello world"
assert concat("foo", "bar") == "foobar"
assert concat(["cow", "dog", "cat"], ["turtle"]) ==
  ["cow", "dog", "cat", "turtle"]
assert concat([42.3, .428], [13.3, 5]) == [42.3, .428, 13.3, 5]
assert concat(#[1, 3, 5], #[3, 5, 6]) == #[1, 3, 5, 6]
assert concat(#['a', 'b'], #['c', 'd', 'e', 'f']) ==
  #['a', 'b', 'c', 'd', 'e', 'f']
assert concat({ "foo" => 7.5 }, { "bar" => 3.7, "baz" => 1 }) ==
  { "foo" => 7.5, "bar" => 3.7, "baz" => 1 }
assert concat({ true => 'i', false => 'y' }, { true => 'h' }) ==
  { true => 'h', false => 'y' }

Concatenates all elements in the list l together. If l is [a, b, c, ...], this is equivalent to a ++ b ++ c ++ .... See concat() for how a single concatenation works.

assert concat_all(["hello ", "world", "foo", "bar"]) ==
  "hello worldfoobar"
assert concat_all([["cow", "dog", "cat"], ["turtle"], [], ["rat"]]) ==
  ["cow", "dog", "cat", "turtle", "rat"]
assert concat_all([#[1, 3, 5], #[3, 5, 6], #[10], #[5, 10, 3]]) ==
  #[1, 3, 5, 6, 10]
assert concat_all([
  { "foo" => 7.5 }
  { "bar" => 3.7, "baz" => 1 }
  { "baz" => 20 }
  { "foo" => 13.1 }
]) == { "foo" => 13.1, "bar" => 3.7, "baz" => 20 }

Calls f for each element in container, collecting the results into a new container.

If container is a list, the order of the mapped elements mirrors the order of the original elements. If collection is a set or map, the order is undefined.

If container is of type Map<K, V>, f must accept a tuple of type (K, V), representing a single key-value pair, and return a tuple of type (L, M) for some L and M, representing a new key-value pair. The resultant type is then Map<L, M>.

If container is of type Option<T>, and container == None, the return value is None. If container is Some(a), the return value is Some(f(a)).

assert map(Some(3), |a| a + 1) == Some(4)
assert map(None, |a| a + 1) == None
assert map([@hi, @hey], |a| a == @hey) == [false, true]
assert map([], |a| a == @hey) == []
assert map(#[{ ch = 'a' }, { ch = 'b' }], .ch) == #['a', 'b']
assert map(#[], .ch) == #[]
assert map({ true => @hi }, |(k, v)| (v, k)) == { @hi => true }
assert map({}, |(k, v)| (v, k)) == {}

Computes a single value by applying the combining function f to each element of the given collection, starting with the initial value init. This is also called a reduce, accumulate, or inject operation.

Calls f(accum, e) for each element e in the given collection. For the first element, accum is init. For each subsequent element, accum is the return value of the last call to f. So accum is computed across multiple calls to f, and the final value of accum after all elements have been processed is the return value of fold.

Put another way, fold() lets you build up an accumulated value by incrementally computing it based on the current element, and the previously accumulated value.

If collection is a list, fold() processes elements in order. If collection is a set or map, the order is undefined.

If collection is of type Map<K, V>, f's first argument, e, will be a tuple of type (K, V), representing the current key-value pair.

assert fold([1, 2, 3], 10, |accum, a| accum + a) == 16
assert fold([], 10, |accum, a| accum + a) == 10
assert fold(#[1, 2, 3], 10, |accum, a| accum + a) == 16
assert fold(#[], 10, |accum, a| accum + a) == 10

let m = { 1 => 2, 3 => 4, 5 => 6 }
assert fold(m, 10, |accum, (k, v)| accum + k + v) == 31

assert fold({}, 10, |accum, (k, v)| accum + k + v) == 10

Calls f for each element in collection, returning a new collection that only contains the elements for which f returns true.

If collection is a list, the returned collection maintains the order of elements in the original collection. If collection is a set or map, the order is undefined.

If collection is of type Map<K, V>, f should accept an argument of type (K, V), representing a key-value pair.

assert filter(["cat", "dog", "mouse"], |a| a < "lion") == ["cat", "dog"]
assert filter([], |a| a < "lion") == []
assert filter(#["cat", "dog", "mouse"], |a| a < "lion") ==
  #["cat", "dog"]
assert filter(#[], |a| a < "lion") == #[]

let m = { "cat" => @cat, "dog" => @dog, "mouse" => @mouse }
assert filter(m, |(k, v)| k < "lion" && v == @dog) == { "dog" => @dog }

assert filter({}, |(k, v)| k < "lion" && v == @dog) == {}

Returns the first element in collection for which f returns true.

If collection is a list, processes elements in order. If collection is a set or map, the order is undefined.

If collection is of type Map<K, V>, f should accept an argument of type (K, V), representing a key-value pair.

assert find(['c', 'z', 'g'], |a| a > 'e') == Some('z')
assert find(['c', 'a'], |a| a > 'e') == None

let found = find(#['c', 'z', 'g'], |a| a > 'e')
// order is undefined
assert found == Some('z') || found == Some('g')

assert find(#['c', 'a'], |a| a > 'e') == None

let found = find({
  'c' => true
  'z' => false
  'g' => false
}, |(k, v)| k > 'e' && !v)
// order is undefined
assert found == Some(('z', false)) || found == Some(('g', false))

assert find(#['c', 'a'], |a| a > 'e') == None

Calls f for each element in collection, returning a new collection that contains every e such that f returned Some(e). This performs a filter() and map() operation at the same time. For elements that should be filtered out, f should return None, and for elements that need to be mapped, f should return Some(e), where e is the new element in the resulting collection.

If collection is a list, the order of the mapped elements mirrors the order of the original elements. If collection is a set or map, the order is undefined.

If collection is of type Map<K, V>, f should accept an argument of type (K, V), representing a key-value pair.

assert filter_map([true, false], |a| if a then Some([a]) else None) ==
  [[true]]
assert filter_map([], |a| if a then Some([a]) else None) == []
assert filter_map(#[true, false], |a| if a then Some([a]) else None) ==
  #[[true]]
assert filter_map(#[], |a| if a then Some([a]) else None) == #[]

let m = { true => [true], false => [false] }
assert filter_map(m, |(k, v)| if k then Some((v, k)) else None) ==
  { [true] => true }

assert filter_map({}, |(k, v)| if k then Some((v, k)) else None) == {}

Computes a new collection and a single value by applying the combining function f to each element of the given collection, starting with the initial value init. This performs a map() and fold() operation at the same time.

Calls f(accum, e) for each element e in the given collection. f returns a tuple (new_accum, new_e). The new_es are collected into a new collection.

For the first element, accum is init. For each subsequent element, accum is the new_accum returned from the last call to f. So accum is computed across multiple calls to f. The final value of accum after all elements have been processed, along with the collection of new_es, is the return value of fold_map().

If collection is of type Map<K, V>, f's first argument, e, will be a tuple of type (K, V), representing the current key-value pair.

assert fold_map(["hi", "bye"], "-", |accum, a|
  (accum ++ a, a ++ "!")
) == ("-hibye", ["hi!", "bye!"])
assert fold_map([], "-", |accum, a|
  (accum ++ a, a ++ "!")
) == ("-", [])

let (final, mapped) = fold_map(#["hi", "bye"], "-", |accum, a|
  (accum ++ a, a ++ "!")
)
assert mapped == #["hi!", "bye!"]
// order is undefined
assert final == "-hibye" || final == "-byehi"

assert fold_map(#[], "-", |accum, a|
  (accum ++ a, a ++ "!")
) == ("-", #[])

let m = { "hi" => "now", "bye" => "later" }
let (final, mapped) = fold_map(m, "-", |accum, (k, v)|
  (accum ++ k ++ v, (k ++ "!", v ++ "!"))
)
assert mapped == { "hi!" => "now!", "bye!" => "later!" }
// order is undefined
assert final == "-hinowbyelater" || final == "-byelaterhinow"

assert fold_map({}, "-", |accum, (k, v)|
  (accum ++ k ++ v, (k ++ "!", v ++ "!"))
) == ("-", {})

Puts elem into collection, returning a new collection. The original collection is not modified.

If collection is a list, elem is added to the front of the list.

If collection is of type Map<K, V>, the second argument to put should be a tuple of type (K, V), representing one key-value pair.

assert put(["second"], "first") == ["first", "second"]
assert put([], "first") == ["first"]
assert put(#["second"], "first") == #["first", "second"]
assert put(#[], "first") == #["first"]
assert put({ "second" => 2 }, ("first", 1)) ==
  { "first" => 1, "second" => 2 }
assert put({}, ("first", 1)) == { "first" => 1 }

Removes elem from collection, returning a new collection. The original collection is not modified. If collection doesn't contain elem, does nothing and returns the original collection.

To delete a key from a map, use remove(), not delete(). delete() works with maps, but it requires a tuple of type (K, V) as the second argument. meaning you need to pass both the key and its associated value, which isn't what you usually want.

assert delete([38.52, 1.7, 4, 1.7], 1.7) == [38.52, 4]
assert delete([38.52, 1.7, 4, 1.7], 37.0) == [38.52, 1.7, 4, 1.7]
assert delete(#[38.52, 1.7, 4, 1.7], 1.7) == #[38.52, 4]
assert delete(#[], 37.0) == #[]
assert delete({ 38.52 => 1.7, 4 => 2.9 }, (38.52, 1.7)) == { 4 => 2.9 }
assert delete({ 38.52 => 1.7, 4 => 2.9 }, (4, 3)) ==
  { 38.52 => 1.7, 4 => 2.9 }

Returns true if collection contains elem.

To check if a key is contained within a map, use key?(), not contains?(). contains?() works with maps, but it accepts a tuple of type (K, V) as the second argument, meaning you need to pass both the key and its associated value, which isn't usually what you want.

assert contains?([38.52, 1.7, 4, 1.7], 1.7)
assert !contains?([38.52, 1.7, 4, 1.7], 37.0)
assert contains?(#[38.52, 1.7, 4, 1.7], 1.7)
assert !contains?(#[38.52, 1.7, 4, 1.7], 37.0)
assert contains?({ 38.52 => 1.7, 4 => 2.9 }, (38.52, 1.7))
assert !contains?({}, (38.52, 1.7))

Calls f for each element in collection, and returns true if f returns true for every element. If collection is empty, returns true.

If collection is of type Map<K, V>, f should accept an argument of type (K, V), representing a key-value pair.

assert all?(['a', 'e', 'a'], |x| x == 'a' || x == 'e')
assert !all?(['a', 'e', 'a'], |x| x == 'a' || x == 'i')
assert all?([], |x| x)
assert all?(#['a', 'e', 'a'], |x| x == 'a' || x == 'e')
assert !all?(#['a', 'e', 'a'], |x| x == 'a' || x == 'i')
assert all?({ 'a' => 1, 'e' => 2 }, |(k, v)|
  (k == 'a' || k == 'e') && v > 0
)
assert !all?({ 'a' => 1, 'e' => 2 }, |(k, v)|
  (k == 'a' || k == 'e') && v > 1
)

Calls f for each element in collection, and returns true if f returns true for at least one element. If collection is empty, returns false.

If collection is of type Map<K, V>, f should accept an argument of type (K, V), representing a key-value pair.

assert any?(['a', 'e', 'a'], |x| x == 'e' || x == 'i')
assert !any?(['a', 'e', 'a'], |x| x == 'o' || x == 'i')
assert !any?([], |x| x == 'e' || x == 'i')
assert any?(#['a', 'e', 'a'], |x| x == 'e' || x == 'i')
assert !any?(#['a', 'e', 'a'], |x| x == 'o' || x == 'i')
assert any?({ 'a' => 1, 'e' => 2 }, |(k, v)| k == 'a' || v > 2)
assert !any?({ 'a' => 1, 'e' => 2 }, |(k, v)| k == 'i' || v > 2)

Converts a to an integer.

If a is a float, this is equivalent to trunc. If a is a character, returns the unicode codepoint of a.

If a is of type String or [Char], tries to parse an integer from the characters in a. Raises CantParseInt if a is empty or contains non-numeric characters.

assert to_int(3.7) == 3
assert to_int('a') == 97
assert to_int(['1', '3', '5']) == 135
assert to_int("83") == 83

Converts a to a float.

If a is an integer, returns the floating point representation of a.

If a is of type String or [Char], tries to parse an integer from the characters in a. Raises CantParseInt if a is empty or contains non-numeric characters.

assert to_float(3 : Int) == 3.0
assert to_float(['1', '.', '3', '5']) == 1.35
assert to_float("2") == 2.0
assert to_float("83.0") == 83.0
assert to_float(".37") == .37

Converts a to a character.

If a is an integer, representing a unicode codepoint, returns the character corresponding to that codepoint.

assert to_char(97 : Int) == 'a'
assert to_char(10 : Int) == '\n'

Converts a to an atom.

If a is a character, returns the atom containing just that character.

If a is of type String or [Char], returns the atom containing the characters given by a.

assert to_atom('a') == @a
assert to_atom(['h', 'i']) == @hi
assert to_atom("hello") == @hello

Converts a to a list.

If a is a set, the resultant list will contain all elements of a, but the order of those elements is undefined.

If a is of type Map<K, V>, the resultant list will contain tuples of type (K, V), each representing a key-value pair in a. The order of the tuples is undefined.

let l = to_list(#[1, 2])
// order is undefined
assert l == [1, 2] || l == [2, 1]

let l = to_list({ "hey" => true, "hi" => false })
// order is undefined
assert l == [("hey", true), ("hi", false)] ||
  l == [("hi", false), ("hey", true)]

Converts a to a set.

If a is a list, the resultant set will contain all elements of a.

If a is of type Map<K, V>, the resultant set will contain tuples of type (K, V), each representing a key-value pair in a.

assert to_set([1, 2]) == #[1, 2]
assert to_set({ "hey" => true, "hi" => false }) ==
  #[("hey", true), ("hi", false)]
assert to_set({}) == #[]

Converts a to a map.

If a is a list or set, a must contain tuples of type (K, V) for some K and V, each representing a key-value pair. The return value will be of type Map<K, V>.

If a is a list, and there are multiple elements in a with the same key, the last element's value will overwrite the others.

If a is a set, and there are multiple elements in a with the same key, the value that takes precedence is undefined, as sets are unordered.

assert to_map([(1, "one"), (2, "two")]) == { 1 => "one", 2 => "two" }
assert to_map([]) == {}
assert to_map(#[("hey", true), ("hi", false)]) ==
  { "hey" => true, "hi" => false }