Zafu/Abstract/Semigroup

`Zafu/Abstract/Semigroup`

source code:

src/Zafu/Abstract/Semigroup.bosatsu

public dependencies: Zafu/Abstract/Eq

Index

Types: Semigroup
Values: combine, combine_all_option, combine_fn, combine_map_all, combine_map_all_option, combine_n, combine_n_positive_from_combine, combine_tree_option, first, intercalate, last, laws_Semigroup, maybe_combine_left, maybe_combine_right, reverse, semigroup_from_combine, semigroup_specialized

Types

`Semigroup[a]`

type Semigroup[a: *]

Values

`combine`

references: Semigroup

def combine[a](inst: Semigroup[a], left: a, right: a) -> a

`combine_all_option`

references: List, Option, Semigroup

def combine_all_option[a](inst: Semigroup[a], items: List[a]) -> Option[a]

`combine_fn`

references: Semigroup

def combine_fn[a](inst: Semigroup[a]) -> (a, a) -> a

`combine_map_all`

references: List, Semigroup

def combine_map_all[a, b](inst: Semigroup[a], head: b, tail: List[b], fn: b -> a) -> a

`combine_map_all_option`

references: List, Option, Semigroup

def combine_map_all_option[a, b](inst: Semigroup[a], items: List[b], fn: b -> a) -> Option[a]

`combine_n`

references: Int, Option, Semigroup

def combine_n[a](inst: Semigroup[a], value: a, n: Int) -> Option[a]

`combine_n_positive_from_combine`

Default repeated-combine implementation with logarithmic combine count.

references: Int

def combine_n_positive_from_combine[a](combine_fn: (a, a) -> a, value: a, n: Int) -> a

`combine_tree_option`

combine this list by forming a balanced tree. Useful for combine operations that don't decrease size

references: List, Option

def combine_tree_option[a](combine: (a, a) -> a, items: List[a]) -> Option[a]

`first`

references: Semigroup

first: forall a: *. Semigroup[a]

`intercalate`

references: Semigroup

def intercalate[a](inst: Semigroup[a], middle: a) -> Semigroup[a]

`last`

references: Semigroup

last: forall a: *. Semigroup[a]

`laws_Semigroup`

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

def laws_Semigroup[a
](inst: Semigroup[a], eq_inst: Zafu/Abstract/Eq::Eq[a], x: a, y: a, z: a) -> Test

`maybe_combine_left`

references: Option, Semigroup

def maybe_combine_left[a](inst: Semigroup[a], left_opt: Option[a], right: a) -> a

`maybe_combine_right`

references: Option, Semigroup

def maybe_combine_right[a](inst: Semigroup[a], left: a, right_opt: Option[a]) -> a

`reverse`

references: Semigroup

def reverse[a](inst: Semigroup[a]) -> Semigroup[a]

`semigroup_from_combine`

Constructor from combine with helper operations derived.

references: Semigroup

def semigroup_from_combine[a](combine_fn: (a, a) -> a) -> Semigroup[a]

`semigroup_specialized`

Constructor for specialized implementations.

references: Int, List, Semigroup

def semigroup_specialized[a](
    combine_fn: (a, a) -> a,
    combine_n_positive_fn: (a, Int) -> a,
    combine_map_all_fn: forall b: *. (b, List[b], b -> a) -> a
) -> Semigroup[a]