Zafu/Collection/LazyTree

source code:

• src/Zafu/Collection/LazyTree.bosatsu

public dependencies: Zafu/Abstract/Applicative, Zafu/Abstract/Eq, Zafu/Abstract/Monad, Zafu/Collection/LazyList

Index

• Types: LazyTree
• Values: applicative_LazyTree, eq_LazyTree, expand, flat_map, map, monad_LazyTree, prune, singleton, unfold, zip_map

Types

LazyTree[a]

type LazyTree[a: +*]

Constructors

• LazyTree(value: a, children: Zafu/Collection/LazyList::LazyList[LazyTree[a]])

Values

applicative_LazyTree

references: LazyTree, Zafu/Abstract/Applicative::Applicative

applicative_LazyTree: Zafu/Abstract/Applicative::Applicative[LazyTree]

eq_LazyTree

references: LazyTree, Zafu/Abstract/Eq::Eq

def eq_LazyTree[a](eq_item: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[LazyTree[a]]

expand

references: Int, LazyTree, Zafu/Collection/LazyList::LazyList

def expand[a
](tree: LazyTree[a], depth: Int, expand_fn: a -> Zafu/Collection/LazyList::LazyList[a]) -> LazyTree[a]

flat_map

references: LazyTree

def flat_map[a, b](tree: LazyTree[a], fn: a -> LazyTree[b]) -> LazyTree[b]

map

references: LazyTree

def map[a, b](tree: LazyTree[a], fn: a -> b) -> LazyTree[b]

monad_LazyTree

references: LazyTree, Zafu/Abstract/Monad::Monad

monad_LazyTree: Zafu/Abstract/Monad::Monad[LazyTree]

prune

references: LazyTree

def prune[a](tree: LazyTree[a]) -> LazyTree[a]

singleton

references: LazyTree

def singleton[a](value: a) -> LazyTree[a]

unfold

references: Int, LazyTree, Zafu/Collection/LazyList::LazyList

def unfold[a,
    b
](depth: Int, init: a, inject: a -> b, expand_fn: a -> Zafu/Collection/LazyList::LazyList[a]) -> LazyTree[b]

zip_map

Combine two trees by interleaving one-step shrinks from either side.

references: Int, LazyTree

def zip_map[a,
    b,
    c](depth: Int, left: LazyTree[a], right: LazyTree[b], fn: (a, b) -> c) -> LazyTree[c]