Zafu/Collection/Chain

source code:

• src/Zafu/Collection/Chain.bosatsu

public dependencies: Zafu/Abstract/Eq, Zafu/Abstract/Foldable, Zafu/Abstract/Hash, Zafu/Abstract/Ord, Zafu/Abstract/Semigroup, Zafu/Abstract/Traverse

Index

• Types: Chain
• Values: any, append, combine_all, concat, concat_all, empty, eq_Chain, exists, filter, flat_map, foldable_Chain, foldl, foldr, for_all, from_List, get, get_or, hash_Chain, is_empty, map, ord_Chain, prepend, singleton, size, to_List, traverse_Chain, uncons_left, uncons_right

Types

Chain[a]

Internal tree used to support O(1) concat while preserving order. Invariant: WrapArray and WrapList only hold collections with at least two items.

type Chain[a: +*]

Values

any

references: Bool, Chain

def any(chain: Chain[Bool]) -> Bool

append

Add an item to the end of a chain.

references: Chain

def append[a](chain: Chain[a], item: a) -> Chain[a]

combine_all

references: Chain, Option, Zafu/Abstract/Semigroup::Semigroup

def combine_all[a](chain: Chain[a], semi: Zafu/Abstract/Semigroup::Semigroup[a]) -> Option[a]

concat

O(1) concatenation of two chains.

references: Chain

def concat[a](left: Chain[a], right: Chain[a]) -> Chain[a]

concat_all

Concatenate all chains from left to right.

references: Chain, List

def concat_all[a](chains: List[Chain[a]]) -> Chain[a]

empty

Empty chain.

references: Chain

empty: forall a: *. Chain[a]

eq_Chain

references: Chain, Zafu/Abstract/Eq::Eq

def eq_Chain[a](eq_item: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[Chain[a]]

exists

references: Bool, Chain

def exists[a](chain: Chain[a], pred: a -> Bool) -> Bool

filter

Keep only elements satisfying pred.

references: Bool, Chain

def filter[a](chain: Chain[a], pred: a -> Bool) -> Chain[a]

flat_map

Map each element to a chain and concatenate.

references: Chain

def flat_map[a, b](chain: Chain[a], fn: a -> Chain[b]) -> Chain[b]

foldable_Chain

references: Chain, Zafu/Abstract/Foldable::Foldable

foldable_Chain: Zafu/Abstract/Foldable::Foldable[Chain]

foldl

Stack-safe left fold.

references: Chain

def foldl[a, b](chain: Chain[a], init: b, fn: (b, a) -> b) -> b

foldr

Stack-safe right fold.

references: Chain

def foldr[a, b](chain: Chain[a], init: b, fn: (a, b) -> b) -> b

for_all

references: Bool, Chain

def for_all[a](chain: Chain[a], pred: a -> Bool) -> Bool

from_List

Build a chain from a list.

references: Chain, List

def from_List[a](list: List[a]) -> Chain[a]

get

Option-returning lookup.

references: Chain, Int, Option

def get[a](chain: Chain[a], idx: Int) -> Option[a]

get_or

Index lookup with fallback thunk.

references: Chain, Int, Unit

def get_or[a](chain: Chain[a], idx: Int, fn: () -> a) -> a

hash_Chain

references: Chain, Zafu/Abstract/Hash::Hash

def hash_Chain[a](hash_item: Zafu/Abstract/Hash::Hash[a]) -> Zafu/Abstract/Hash::Hash[Chain[a]]

is_empty

references: Bool, Chain

def is_empty[a](chain: Chain[a]) -> Bool

map

Map over all elements.

references: Chain

def map[a, b](chain: Chain[a], fn: a -> b) -> Chain[b]

ord_Chain

references: Chain, Zafu/Abstract/Ord::Ord

def ord_Chain[a](ord_item: Zafu/Abstract/Ord::Ord[a]) -> Zafu/Abstract/Ord::Ord[Chain[a]]

prepend

Add an item to the front of a chain.

references: Chain

def prepend[a](item: a, chain: Chain[a]) -> Chain[a]

singleton

Single-item chain.

references: Chain

def singleton[a](item: a) -> Chain[a]

size

Number of elements in the chain.

references: Chain, Int

def size[a](chain: Chain[a]) -> Int

to_List

Convert to a list in iteration order.

references: Chain, List

def to_List[a](chain: Chain[a]) -> List[a]

traverse_Chain

references: Chain, Zafu/Abstract/Traverse::Traverse

traverse_Chain: Zafu/Abstract/Traverse::Traverse[Chain]

uncons_left

references: Chain, Option, Tuple2

def uncons_left[a](chain: Chain[a]) -> Option[(a, Chain[a])]

uncons_right

references: Chain, Option, Tuple2

def uncons_right[a](chain: Chain[a]) -> Option[(Chain[a], a)]