Zafu/Abstract/Foldable

`Zafu/Abstract/Foldable`

source code:

src/Zafu/Abstract/Foldable.bosatsu

public dependencies: Zafu/Abstract/Applicative, Zafu/Abstract/Eq, Zafu/Abstract/Monoid, Zafu/Abstract/Ord, Zafu/Abstract/Semigroup, Zafu/Control/IterState

Index

Types: Foldable
Values: all, any, collect_first_some, collect_fold_some, combine_all, combine_all_option, contains, count, drop_while_to_List, exists, filter_to_List, find, fold, fold_map, fold_map_option, foldable_from_fold_iters, foldable_from_foldl_iter, foldable_from_foldr_iter, foldable_from_folds, foldable_specialized, foldl, foldl_iter, foldr, foldr_iter, for_all, get, intercalate, is_empty, laws_Foldable, maximum_by_list, maximum_by_option, maximum_list, maximum_option, minimum_by_list, minimum_by_option, minimum_list, minimum_option, non_empty, reduce_left_option, reduce_left_to_option, reduce_right_option, reduce_right_to_option, sequence_void, size, take_while_to_List, to_List, traverse_void

Types

`Foldable[f]`

type Foldable[f: * -> *]

Values

`all`

references: Bool, Foldable

def all[a: * -> *](fa: a[Bool], inst: Foldable[a]) -> Bool

`any`

references: Bool, Foldable

def any[a: * -> *](fa: a[Bool], inst: Foldable[a]) -> Bool

`collect_first_some`

references: Foldable, Option

def collect_first_some[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], fn: b -> Option[c]) -> Option[c]

`collect_fold_some`

references: Foldable, Option, Zafu/Abstract/Monoid::Monoid

def collect_fold_some[a: * -> *,
    b,
    c
](fa: a[b], inst: Foldable[a], monoid: Zafu/Abstract/Monoid::Monoid[c], fn: b -> Option[c]) -> c

`combine_all`

references: Foldable, Zafu/Abstract/Monoid::Monoid

def combine_all[a: * -> *,
    b](fa: a[b], inst: Foldable[a], monoid: Zafu/Abstract/Monoid::Monoid[b]) -> b

`combine_all_option`

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

def combine_all_option[a: * -> *,
    b](fa: a[b], inst: Foldable[a], semigroup: Zafu/Abstract/Semigroup::Semigroup[b]) -> Option[b]

`contains`

references: Bool, Foldable, Zafu/Abstract/Eq::Eq

def contains[a: * -> *,
    b](fa: a[b], inst: Foldable[a], eq_inst: Zafu/Abstract/Eq::Eq[b], target: b) -> Bool

`count`

references: Bool, Foldable, Int

def count[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> Int

`drop_while_to_List`

references: Bool, Foldable, List

def drop_while_to_List[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> List[b]

`exists`

references: Bool, Foldable

def exists[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> Bool

`filter_to_List`

references: Bool, Foldable, List

def filter_to_List[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> List[b]

`find`

references: Bool, Foldable, Option

def find[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> Option[b]

`fold`

references: Foldable, Zafu/Abstract/Monoid::Monoid

def fold[a: * -> *, b](fa: a[b], inst: Foldable[a], monoid: Zafu/Abstract/Monoid::Monoid[b]) -> b

`fold_map`

references: Foldable, Zafu/Abstract/Monoid::Monoid

def fold_map[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], monoid: Zafu/Abstract/Monoid::Monoid[c], fn: b -> c) -> c

`fold_map_option`

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

def fold_map_option[a: * -> *,
    b,
    c
](fa: a[b], inst: Foldable[a], semigroup: Zafu/Abstract/Semigroup::Semigroup[c], fn: b -> c) -> Option[c]

`foldable_from_fold_iters`

references: Foldable, Zafu/Control/IterState::IterState

def foldable_from_fold_iters[a: * -> *](
    foldl_iter_fn: forall b: *, c: *. (a[b], c, (c, b) -> Zafu/Control/IterState::IterState[c, c]) -> Zafu/Control/IterState::IterState[c, c],
    foldr_iter_fn: forall b: *, c: *. (a[b], c, (b, c) -> Zafu/Control/IterState::IterState[c, c]) -> Zafu/Control/IterState::IterState[c, c]
) -> Foldable[a]

`foldable_from_foldl_iter`

references: Foldable, Zafu/Control/IterState::IterState

def foldable_from_foldl_iter[a: * -> *](
    foldl_iter_fn: forall b: *, c: *. (a[b], c, (c, b) -> Zafu/Control/IterState::IterState[c, c]) -> Zafu/Control/IterState::IterState[c, c]
) -> Foldable[a]

`foldable_from_foldr_iter`

references: Foldable, Zafu/Control/IterState::IterState

def foldable_from_foldr_iter[a: * -> *](
    foldr_iter_fn: forall b: *, c: *. (a[b], c, (b, c) -> Zafu/Control/IterState::IterState[c, c]) -> Zafu/Control/IterState::IterState[c, c]
) -> Foldable[a]

`foldable_from_folds`

references: Foldable

def foldable_from_folds[a: * -> *](
    foldl_fn: forall b: *, c: *. (a[b], c, (c, b) -> c) -> c,
    foldr_fn: forall b: *, c: *. (a[b], c, (b, c) -> c) -> c
) -> Foldable[a]

`foldable_specialized`

references: Bool, Foldable, Int, List, Zafu/Abstract/Monoid::Monoid, Zafu/Control/IterState::IterState

def foldable_specialized[a: * -> *](
    foldl_fn: forall b: *, c: *. (a[b], c, (c, b) -> c) -> c,
    foldr_fn: forall b: *, c: *. (a[b], c, (b, c) -> c) -> c,
    fold_map_fn: forall b: *, c: *. (a[b], Zafu/Abstract/Monoid::Monoid[c], b -> c) -> c,
    foldl_iter_fn: forall b: *, c: *. (a[b], c, (c, b) -> Zafu/Control/IterState::IterState[c, c]) -> Zafu/Control/IterState::IterState[c, c],
    foldr_iter_fn: forall b: *, c: *. (a[b], c, (b, c) -> Zafu/Control/IterState::IterState[c, c]) -> Zafu/Control/IterState::IterState[c, c],
    is_empty_fn: forall b: *. a[b] -> Bool,
    size_fn: forall b: *. a[b] -> Int,
    to_List_fn: forall b: *. a[b] -> List[b]
) -> Foldable[a]

`foldl`

references: Foldable

def foldl[a: * -> *, b, c](fa: a[b], inst: Foldable[a], init: c, fn: (c, b) -> c) -> c

`foldl_iter`

references: Foldable, Zafu/Control/IterState::IterState

def foldl_iter[a: * -> *,
    b,
    c
](fa: a[b], inst: Foldable[a], init: c, fn: (c, b) -> Zafu/Control/IterState::IterState[c, c]) -> c

`foldr`

references: Foldable

def foldr[a: * -> *, b, c](fa: a[b], inst: Foldable[a], init: c, fn: (b, c) -> c) -> c

`foldr_iter`

references: Foldable, Zafu/Control/IterState::IterState

def foldr_iter[a: * -> *,
    b,
    c
](fa: a[b], inst: Foldable[a], init: c, fn: (b, c) -> Zafu/Control/IterState::IterState[c, c]) -> c

`for_all`

references: Bool, Foldable

def for_all[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> Bool

`get`

references: Foldable, Int, Option

def get[a: * -> *, b](fa: a[b], inst: Foldable[a], idx: Int) -> Option[b]

`intercalate`

references: Foldable, Zafu/Abstract/Monoid::Monoid

def intercalate[a: * -> *,
    b](fa: a[b], inst: Foldable[a], monoid: Zafu/Abstract/Monoid::Monoid[b], middle: b) -> b

`is_empty`

references: Bool, Foldable

def is_empty[a: * -> *, b](fa: a[b], inst: Foldable[a]) -> Bool

`laws_Foldable`

references: Foldable, Test, Zafu/Abstract/Eq::Eq

def laws_Foldable[a: * -> *,
    b](inst: Foldable[a], eq_item: Zafu/Abstract/Eq::Eq[b], fa: a[b]) -> Test

`maximum_by_list`

references: Foldable, List, Zafu/Abstract/Ord::Ord

def maximum_by_list[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], ord_b: Zafu/Abstract/Ord::Ord[c], fn: b -> c) -> List[b]

`maximum_by_option`

references: Foldable, Option, Zafu/Abstract/Ord::Ord

def maximum_by_option[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], ord_b: Zafu/Abstract/Ord::Ord[c], fn: b -> c) -> Option[b]

`maximum_list`

references: Foldable, List, Zafu/Abstract/Ord::Ord

def maximum_list[a: * -> *,
    b](fa: a[b], inst: Foldable[a], ord_inst: Zafu/Abstract/Ord::Ord[b]) -> List[b]

`maximum_option`

references: Foldable, Option, Zafu/Abstract/Ord::Ord

def maximum_option[a: * -> *,
    b](fa: a[b], inst: Foldable[a], ord_inst: Zafu/Abstract/Ord::Ord[b]) -> Option[b]

`minimum_by_list`

references: Foldable, List, Zafu/Abstract/Ord::Ord

def minimum_by_list[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], ord_b: Zafu/Abstract/Ord::Ord[c], fn: b -> c) -> List[b]

`minimum_by_option`

references: Foldable, Option, Zafu/Abstract/Ord::Ord

def minimum_by_option[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], ord_b: Zafu/Abstract/Ord::Ord[c], fn: b -> c) -> Option[b]

`minimum_list`

references: Foldable, List, Zafu/Abstract/Ord::Ord

def minimum_list[a: * -> *,
    b](fa: a[b], inst: Foldable[a], ord_inst: Zafu/Abstract/Ord::Ord[b]) -> List[b]

`minimum_option`

references: Foldable, Option, Zafu/Abstract/Ord::Ord

def minimum_option[a: * -> *,
    b](fa: a[b], inst: Foldable[a], ord_inst: Zafu/Abstract/Ord::Ord[b]) -> Option[b]

`non_empty`

references: Bool, Foldable

def non_empty[a: * -> *, b](fa: a[b], inst: Foldable[a]) -> Bool

`reduce_left_option`

references: Foldable, Option

def reduce_left_option[a: * -> *, b](fa: a[b], inst: Foldable[a], combine: (b, b) -> b) -> Option[b]

`reduce_left_to_option`

references: Foldable, Option

def reduce_left_to_option[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], first: b -> c, combine: (c, b) -> c) -> Option[c]

`reduce_right_option`

references: Foldable, Option

def reduce_right_option[a: * -> *,
    b](fa: a[b], inst: Foldable[a], combine: (b, b) -> b) -> Option[b]

`reduce_right_to_option`

references: Foldable, Option

def reduce_right_to_option[a: * -> *,
    b,
    c](fa: a[b], inst: Foldable[a], first: b -> c, combine: (b, c) -> c) -> Option[c]

`sequence_void`

references: Foldable, Unit, Zafu/Abstract/Applicative::Applicative

def sequence_void[a: * -> *,
    b: * -> *,
    c](fga: a[b[c]], inst: Foldable[a], app: Zafu/Abstract/Applicative::Applicative[b]) -> b[()]

`size`

references: Foldable, Int

def size[a: * -> *, b](fa: a[b], inst: Foldable[a]) -> Int

`take_while_to_List`

references: Bool, Foldable, List

def take_while_to_List[a: * -> *, b](fa: a[b], inst: Foldable[a], pred: b -> Bool) -> List[b]

`to_List`

references: Foldable, List

def to_List[a: * -> *, b](fa: a[b], inst: Foldable[a]) -> List[b]

`traverse_void`

references: Foldable, Unit, Zafu/Abstract/Applicative::Applicative

def traverse_void[a: * -> *,
    b,
    c: * -> *,
    d
](fa: a[b], inst: Foldable[a], app: Zafu/Abstract/Applicative::Applicative[c], fn: b -> c[d]) -> c[()]