Zafu/Abstract/Monad

`Zafu/Abstract/Monad`

source code:

src/Zafu/Abstract/Monad.bosatsu

public dependencies: Zafu/Abstract/Applicative, Zafu/Abstract/Eq, Zafu/Control/IterState

Index

Types: Monad
Values: flat_map, flatten, laws_Monad, monad_from_applicative_flat_map_tailrec_steps, monad_to_applicative, tailrec_steps

Types

`Monad[f]`

type Monad[f: * -> *]

Values

`flat_map`

references: Monad

def flat_map[a: * -> *, b, c](fa: a[b], inst: Monad[a], fn: b -> a[c]) -> a[c]

`flatten`

references: Monad

def flatten[a: * -> *, b](ffa: a[a[b]], inst: Monad[a]) -> a[b]

`laws_Monad`

references: Monad, Test, Zafu/Abstract/Eq::Eq, Zafu/Control/IterState::IterState

def laws_Monad[a: * -> *, b, c, d](
    inst: Monad[a],
    eq_fa: Zafu/Abstract/Eq::Eq[a[b]],
    eq_fb: Zafu/Abstract/Eq::Eq[a[c]],
    eq_fc: Zafu/Abstract/Eq::Eq[a[d]],
    eq_fstate_ab: Zafu/Abstract/Eq::Eq[a[Zafu/Control/IterState::IterState[b, c]]],
    fa: a[b],
    x: b,
    fn_ab: b -> a[c],
    fn_bc: c -> a[d],
    fn_map: b -> c,
    tailrec_seed: b,
    tailrec_step: b -> a[Zafu/Control/IterState::IterState[b, c]]
) -> Test

`monad_from_applicative_flat_map_tailrec_steps`

references: Int, Monad, Zafu/Abstract/Applicative::Applicative, Zafu/Control/IterState::IterState

def monad_from_applicative_flat_map_tailrec_steps[a: * -> *](
    applicative_inst: Zafu/Abstract/Applicative::Applicative[a],
    flat_map_fn: forall b: *, c: *. (a[b], b -> a[c]) -> a[c],
    tailrec_steps_fn: forall b: *, c: *. (Int, b, b -> a[Zafu/Control/IterState::IterState[b, c]]) -> a[Zafu/Control/IterState::IterState[b, c]]
) -> Monad[a]

`monad_to_applicative`

references: Monad, Zafu/Abstract/Applicative::Applicative

def monad_to_applicative[a: * -> *](inst: Monad[a]) -> Zafu/Abstract/Applicative::Applicative[a]

`tailrec_steps`

Instance implementations should prefer loop-based stepping so large max_steps can run stack-safely. If using flat_map hides recursion under lambdas, duplicating a small amount of sequencing logic is acceptable.

references: Int, Monad, Zafu/Control/IterState::IterState

def tailrec_steps[a: * -> *,
    b,
    c
](inst: Monad[a], max_steps: Int, init: b, step: b -> a[Zafu/Control/IterState::IterState[b, c]]) -> a[Zafu/Control/IterState::IterState[b, c]]