Returns true if the predicate f returns True for each element in the ShineTree. Returns False otherwise.

Examples

shine_tree.all(shine_tree.empty, fn(x) { x == 0 })
// -> True

all(shine_tree.from_list([-1, -42]), fn(x) { x < 0 })
// -> True

all(shine_tree.from_list([2, 4, 6, 8, 10, 11]), int.is_even)
// -> False

Returns True if the predicate f returns True for any element in the ShineTree. Returns False otherwise.

Examples

// No items in the tree will always be false
any(shine_tree.empty, int.is_even)
// -> False

any([10, 32, 42, 43, 44], fn(x) { x == 42 })
// -> True

any([3, 4], fn(x) { x + 1 == 42 })
// -> False

Counts the number of elements in a given ShineTree satisfying a given predicate.

This function has to traverse the entire tree to determine the number of elements, so it runs in linear time.

Examples

count(shine_tree.from_list([2, 3, 4, 5, 6, 7, 8, 9, 10]), int.is_even)
// -> 5

Compares two trees for equality. Since trees can have many shapes, the items can be in the correct order and values, but the tree is balanced differently.

This function reduces over the two trees and compares their values, immediately returning False if they are not equal.

Creates a new tree containing all the elements of the given tree, for which the given predicate returns True.

shine_tree.from_list([1, 2, 3, 4, 5, 6, 7])
|> filter(int.is_odd)
// -> shine_tree.from_list([1, 3, 5, 7])

Reduces all the elements of the given tree into a single value, made by calling a given function on all the elements, traversing the tree from left to right.

fold_l(shine_tree.from_list([1, 2, 3]), 0, int.add) is the equivalent of add(add(add(0, 1), 2), 3).

// calculate 20! (factorial)
let n = 20
shine_tree.fold_l(shine_tree.range(2, n), int.multiply)
// -> 2432902008176640000

Reduces all the elements of the given tree into a single value, made by calling a given function on all the elements, traversing the tree from left to right.

fold_r(shine_tree.from_list([1, 2, 3]), 0, int.add) is the equivalent of add(add(add(0, 3), 2), 1).

// calculate 20! (factorial)
let n = 20
shine_tree.fold_r(shine_tree.range(2, n), int.multiply)
// -> 2432902008176640000

Fold a given value over the items of a given tree, starting with the beginning until the given function returns Stop.

The accumulated value is then returned.

Examples

fold_until(shine_tree.from_list([2, 3, 4, 5, 6, 7, 8, 9, 10]), 0, fn(acc, x) {
  case x {
    5 -> Stop(acc + 1)
    _ -> Continue(acc + x)
  }
})
// -> 10

Creates a new tree containing all the elements of the given list.

shine_tree.from_list([1, 2, 3, 4, 5, 6, 7])
// -> It's a ShineTree with all the items in it!
// Were you expecting a list?

Maps all the elements of the given tree into a new tree where each element has been transformed by the given function.

let tree = shine_tree.from_list([1, 2, 3])
shine_tree.map(tree, int.multiply(2, _))
// -> shine_tree.from_list([2, 4, 6])

Pops an element from the end of the given tree.

If there are no items, it returns Error(Nil), otherwise it returns the popped item, and the resulting tree with the element removed.

let tree = shine_tree.from_list([1, 2, 3])
shine_tree.pop(tree)
// -> Ok(3, shine_tree.from_list([1, 2]))

shine_tree.empty |> shine_tree.pop
// -> Error(Nil)

Pushes an element to the end of the given tree.

let tree = shine_tree.from_list([1, 2, 3])
shine_tree.push(tree, 4)
// -> shine_tree.from_list([1, 2, 3, 4])

Creates a tree of n consecutive integers, starting from start. and finishing with finish.

Examples

let ten_items = shine_tree.range(1, 10)

Pops an element from the front of the given tree.

If there are no items, it returns Error(Nil), otherwise it returns the popped item, and the resulting tree with the element removed.

let tree = shine_tree.from_list([1, 2, 3])
shine_tree.shift(tree)
// -> Ok(1, shine_tree.from_list([2, 3]))

shine_tree.empty |> shine_tree.pop
// -> Error(Nil)

Creates an iterator from a given tree, yielding each element in succession until there are no elements left.

Examples

let iter = unfold(shine_tree.from_list([1, 2, 3]))

let #(num, iter) = iterator.step(iter)
// -> Next(1, Iterator(Int))
let #(num, iter) = iterator.step(iter)
// -> Next(2, Iterator(Int))
let #(num, iter) = iterator.step(iter)
// -> Next(3, Iterator(Int))
let a = iterator.step(iter)
// -> Done

Creates a new list containing all the elements of the given tree.

shine_tree.from_list([1, 2, 3, 4, 5, 6, 7])
|> to_list
// -> [1, 2, 3, 4, 5, 6, 7]

Pushes an element to the beginning of the given tree.

let tree = shine_tree.from_list([1, 2, 3])
shine_tree.unshift(tree, 0)
// -> shine_tree.from_list([0, 1, 2, 3])