gens

Types

pub opaque type Generator(a)

Values

pub fn drop(ga: Generator(a), steps: Int) -> Generator(a)

Drops the first n generated elements

new()                   // [0, 1, 2, 3, 4..]
|> drop(4)              // [4, 5, 6, 7..]
|> filter(int.is_even)  // [4, 6, 8..]
|> gen(5)
// -> [4, 6, 8, 10, 12]
new()                   // [0, 1, 2, 3, 4..]
|> filter(int.is_even)  // [0, 2, 4, 6, 8..]
|> drop(4)              // [8, 10, 12..]
|> gen(5)
// -> [8, 10, 12, 14, 16]
pub fn filter(ga: Generator(a), f: fn(a) -> Bool) -> Generator(a)

Filters elements from the generated list

new()
|> filter(fn(x) { x % 2 == 0 })
|> filter(fn(x) { x != 4 })
|> gen(5)
// -> [0, 2, 6, 8, 10]
pub fn gen(ga: Generator(a), n: Int) -> List(a)

Generates a finite list from a generator and a length

gen(new(), 5)
// -> [0, 1, 2, 3, 4]
pub fn list_zip(la: List(a), gb: Generator(b)) -> List(#(a, b))

Zips a list with an infinite list

["a", "b", "c"] 
|> list_zip(new())
// -> [#("a", 0), #("b", 1), #("c", 2)]
pub fn map(ga: Generator(a), f: fn(a) -> b) -> Generator(b)

Maps each element of the generated list

new()
|> map(fn(x) { x + 3 })
|> map(int.to_string)
|> gen(5)
// -> ["3", "4", "5", "6", "7"]
pub fn new() -> Generator(Int)

Default generator for the list of natural numbers [0..]

new() |> gen(5)
// -> [0, 1, 2, 3, 4]
pub fn next(ga: Generator(a)) -> #(a, Generator(a))

Yields one element and advances the generator

let #(x, g) = new() |> next
// -> #(0, Generator(Int))
g |> gen(3)
// -> [1, 2, 3]
pub fn zip(
  ga: Generator(a),
  gb: Generator(b),
) -> Generator(#(a, b))

Combines two generators into one \

  • The resulting index is the maximum of the two gens
  • The filters get combined
  • For separate indexes, do list.zip(gen(g1, n), gen(g2, n))
let g1 = new() |> map(fn(x) { x + 2 })
let g2 = new() |> filter(int.is_even)
zip(g1, g2)
|> gen(3)
// -> [#(2, 0), #(4, 2), #(6, 4)]
Search Document