Zafu/Collection/NonEmptyChain

source code:

• src/Zafu/Collection/NonEmptyChain.bosatsu

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

Index

• Types: NonEmptyChain
• Values: any, append, combine_all, concat, concat_all, distinct_by_hash, eq_NonEmptyChain, exists, filter, flat_map, foldable_NonEmptyChain, foldl, foldr, for_all, from_Chain, from_List, from_append, from_prepend, get, get_or, hash_NonEmptyChain, head, init, last, map, ord_NonEmptyChain, prepend, reverse, set, singleton, size, sort, sum, sumf, tail, to_Chain, to_List, to_NonEmptyList, traverse_NonEmptyChain, uncons, uncons_right, zip

Types

NonEmptyChain[a]

type NonEmptyChain[a: +*]

Constructors

• Append(init: Zafu/Collection/Chain::Chain[a], last: a)
• Prepend(head: a, tail: Zafu/Collection/Chain::Chain[a])

Values

any

references: Bool, NonEmptyChain

def any(items: NonEmptyChain[Bool]) -> Bool

append

references: NonEmptyChain

def append[a](items: NonEmptyChain[a], item: a) -> NonEmptyChain[a]

combine_all

references: NonEmptyChain, Zafu/Abstract/Semigroup::Semigroup

def combine_all[a](items: NonEmptyChain[a], semi: Zafu/Abstract/Semigroup::Semigroup[a]) -> a

concat

references: NonEmptyChain

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

concat_all

references: NonEmptyChain

def concat_all[a](items: NonEmptyChain[NonEmptyChain[a]]) -> NonEmptyChain[a]

distinct_by_hash

references: NonEmptyChain, Zafu/Abstract/Hash::Hash

def distinct_by_hash[a](h: Zafu/Abstract/Hash::Hash[a], items: NonEmptyChain[a]) -> NonEmptyChain[a]

eq_NonEmptyChain

references: NonEmptyChain, Zafu/Abstract/Eq::Eq

def eq_NonEmptyChain[a](eq_item: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[NonEmptyChain[a]]

exists

references: Bool, NonEmptyChain

def exists[a](items: NonEmptyChain[a], pred: a -> Bool) -> Bool

filter

references: Bool, NonEmptyChain, Option

def filter[a](items: NonEmptyChain[a], pred: a -> Bool) -> Option[NonEmptyChain[a]]

flat_map

references: NonEmptyChain

def flat_map[a, b](items: NonEmptyChain[a], fn: a -> NonEmptyChain[b]) -> NonEmptyChain[b]

foldable_NonEmptyChain

references: NonEmptyChain, Zafu/Abstract/Foldable::Foldable

foldable_NonEmptyChain: Zafu/Abstract/Foldable::Foldable[NonEmptyChain]

foldl

references: NonEmptyChain

def foldl[a, b](items: NonEmptyChain[a], init: b, fn: (b, a) -> b) -> b

foldr

references: NonEmptyChain

def foldr[a, b](items: NonEmptyChain[a], init: b, fn: (a, b) -> b) -> b

for_all

references: Bool, NonEmptyChain

def for_all[a](items: NonEmptyChain[a], pred: a -> Bool) -> Bool

from_Chain

references: NonEmptyChain, Option, Zafu/Collection/Chain::Chain

def from_Chain[a](items: Zafu/Collection/Chain::Chain[a]) -> Option[NonEmptyChain[a]]

from_List

references: List, NonEmptyChain, Option

def from_List[a](items: List[a]) -> Option[NonEmptyChain[a]]

from_append

references: NonEmptyChain, Zafu/Collection/Chain::Chain

def from_append[a](init0: Zafu/Collection/Chain::Chain[a], last0: a) -> NonEmptyChain[a]

from_prepend

references: NonEmptyChain, Zafu/Collection/Chain::Chain

def from_prepend[a](head0: a, tail0: Zafu/Collection/Chain::Chain[a]) -> NonEmptyChain[a]

get

references: Int, NonEmptyChain, Option

def get[a](items: NonEmptyChain[a], idx: Int) -> Option[a]

get_or

references: Int, NonEmptyChain, Unit

def get_or[a](items: NonEmptyChain[a], idx: Int, on_missing: () -> a) -> a

hash_NonEmptyChain

references: NonEmptyChain, Zafu/Abstract/Hash::Hash

def hash_NonEmptyChain[a
](hash_item: Zafu/Abstract/Hash::Hash[a]) -> Zafu/Abstract/Hash::Hash[NonEmptyChain[a]]

head

references: NonEmptyChain

def head[a](items: NonEmptyChain[a]) -> a

init

references: NonEmptyChain, Zafu/Collection/Chain::Chain

def init[a](items: NonEmptyChain[a]) -> Zafu/Collection/Chain::Chain[a]

last

references: NonEmptyChain

def last[a](items: NonEmptyChain[a]) -> a

map

references: NonEmptyChain

def map[a, b](items: NonEmptyChain[a], fn: a -> b) -> NonEmptyChain[b]

ord_NonEmptyChain

references: NonEmptyChain, Zafu/Abstract/Ord::Ord

def ord_NonEmptyChain[a
](ord_item: Zafu/Abstract/Ord::Ord[a]) -> Zafu/Abstract/Ord::Ord[NonEmptyChain[a]]

prepend

references: NonEmptyChain

def prepend[a](item: a, items: NonEmptyChain[a]) -> NonEmptyChain[a]

reverse

references: NonEmptyChain

def reverse[a](items: NonEmptyChain[a]) -> NonEmptyChain[a]

set

references: Int, NonEmptyChain, Option

def set[a](items: NonEmptyChain[a], idx: Int, value: a) -> Option[NonEmptyChain[a]]

singleton

references: NonEmptyChain

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

size

references: Int, NonEmptyChain

def size[a](items: NonEmptyChain[a]) -> Int

sort

references: NonEmptyChain, Order

def sort[a](items: NonEmptyChain[a], order: Order[a]) -> NonEmptyChain[a]

sum

references: Int, NonEmptyChain

def sum(items: NonEmptyChain[Int]) -> Int

sumf

references: Float64, NonEmptyChain

def sumf(items: NonEmptyChain[Float64]) -> Float64

tail

references: NonEmptyChain, Zafu/Collection/Chain::Chain

def tail[a](items: NonEmptyChain[a]) -> Zafu/Collection/Chain::Chain[a]

to_Chain

references: NonEmptyChain, Zafu/Collection/Chain::Chain

def to_Chain[a](items: NonEmptyChain[a]) -> Zafu/Collection/Chain::Chain[a]

to_List

references: List, NonEmptyChain

def to_List[a](items: NonEmptyChain[a]) -> List[a]

to_NonEmptyList

references: NonEmptyChain, Zafu/Collection/NonEmptyList::NonEmptyList

def to_NonEmptyList[a](items: NonEmptyChain[a]) -> Zafu/Collection/NonEmptyList::NonEmptyList[a]

traverse_NonEmptyChain

references: NonEmptyChain, Zafu/Abstract/Traverse::Traverse

traverse_NonEmptyChain: Zafu/Abstract/Traverse::Traverse[NonEmptyChain]

uncons

references: NonEmptyChain, Tuple2, Zafu/Collection/Chain::Chain

def uncons[a](items: NonEmptyChain[a]) -> (a, Zafu/Collection/Chain::Chain[a])

uncons_right

references: NonEmptyChain, Tuple2, Zafu/Collection/Chain::Chain

def uncons_right[a](items: NonEmptyChain[a]) -> (Zafu/Collection/Chain::Chain[a], a)

zip

references: NonEmptyChain, Tuple2

def zip[a, b](left: NonEmptyChain[a], right: NonEmptyChain[b]) -> NonEmptyChain[(a, b)]