This is an alias for fold_l.

This is an alias for fold_r.

This is an alias for first.

This is an alias for last.

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

Returns True if the given value is contained in the given tree.

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

Calls a function for each element in the tree, discarding the return value.

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])

Returns a new tree containing only the elements from the first tree where the given function returns Ok(b).

Finds the first element in a given tree that satisfies the given predicate.

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

Finds the first element in a given tree for which the given function returns Ok(val).

shine_tree.from_list([1, 2, 3, 4, 5, 6, 7])
|> find_map(fn(u) {
  case u > 5 {
    True -> Ok(u)
    False -> Error(Nil)
  }
})
// -> 2

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?

Get the value at the given index in the tree if it exists.

This function takes the tree, and groups the values by a returned key into a Dict. It does not sort the values, or preserve the order.

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)

Returns the number of elements in the given tree.

This is an O(1) operation, because the size is cached in the tree at the time it is created.

Sort a ShineTree using the compare function using a “quicksort” algorithm.

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])