Zafu/Collection/NonEmptyList

source code:

• src/Zafu/Collection/NonEmptyList.bosatsu

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

Index

• Types: NonEmptyList
• Values: any, append, combine_all, concat, concat_all, distinct_by_hash, eq_NonEmptyList, exists, filter, flat_map, foldable_NonEmptyList, foldl, foldr, for_all, from_List, from_append, from_prepend, get, get_or, hash_NonEmptyList, head, is_empty, last, map, ord_NonEmptyList, prepend, reverse, set, singleton, size, sort, sum, sumf, tail, to_List, traverse_NonEmptyList, uncons, zip

Types

NonEmptyList[a]

type NonEmptyList[a: +*]

Constructors

• NonEmptyList(head: a, tail: List[a])

Values

any

references: Bool, NonEmptyList

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

append

references: NonEmptyList

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

combine_all

references: NonEmptyList, Zafu/Abstract/Semigroup::Semigroup

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

concat

references: NonEmptyList

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

concat_all

references: NonEmptyList

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

distinct_by_hash

references: NonEmptyList, Zafu/Abstract/Hash::Hash

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

eq_NonEmptyList

references: NonEmptyList, Zafu/Abstract/Eq::Eq

def eq_NonEmptyList[a](eq_item: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[NonEmptyList[a]]

exists

references: Bool, NonEmptyList

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

filter

references: Bool, NonEmptyList, Option

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

flat_map

references: NonEmptyList

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

foldable_NonEmptyList

references: NonEmptyList, Zafu/Abstract/Foldable::Foldable

foldable_NonEmptyList: Zafu/Abstract/Foldable::Foldable[NonEmptyList]

foldl

references: NonEmptyList

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

foldr

references: NonEmptyList

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

for_all

references: Bool, NonEmptyList

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

from_List

references: List, NonEmptyList, Option

def from_List[a](lst: List[a]) -> Option[NonEmptyList[a]]

from_append

references: List, NonEmptyList

def from_append[a](lst: List[a], last0: a) -> NonEmptyList[a]

from_prepend

references: List, NonEmptyList

def from_prepend[a](head0: a, tail0: List[a]) -> NonEmptyList[a]

get

references: Int, NonEmptyList, Option

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

get_or

references: Int, NonEmptyList, Unit

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

hash_NonEmptyList

references: NonEmptyList, Zafu/Abstract/Hash::Hash

def hash_NonEmptyList[a
](hash_item: Zafu/Abstract/Hash::Hash[a]) -> Zafu/Abstract/Hash::Hash[NonEmptyList[a]]

head

references: NonEmptyList

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

is_empty

references: Bool, NonEmptyList

def is_empty[a](items: NonEmptyList[a]) -> Bool

last

references: NonEmptyList

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

map

references: NonEmptyList

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

ord_NonEmptyList

references: NonEmptyList, Zafu/Abstract/Ord::Ord

def ord_NonEmptyList[a
](ord_item: Zafu/Abstract/Ord::Ord[a]) -> Zafu/Abstract/Ord::Ord[NonEmptyList[a]]

prepend

references: NonEmptyList

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

reverse

references: NonEmptyList

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

set

references: Int, NonEmptyList, Option

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

singleton

references: NonEmptyList

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

size

references: Int, NonEmptyList

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

sort

references: NonEmptyList, Order

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

sum

references: Int, NonEmptyList

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

sumf

references: Float64, NonEmptyList

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

tail

references: List, NonEmptyList

def tail[a](items: NonEmptyList[a]) -> List[a]

to_List

references: List, NonEmptyList

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

traverse_NonEmptyList

references: NonEmptyList, Zafu/Abstract/Traverse::Traverse

traverse_NonEmptyList: Zafu/Abstract/Traverse::Traverse[NonEmptyList]

uncons

references: List, NonEmptyList, Tuple2

def uncons[a](items: NonEmptyList[a]) -> (a, List[a])

zip

references: NonEmptyList, Tuple2

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