Zafu/Collection/List

source code:

• src/Zafu/Collection/List.bosatsu

public dependencies: Zafu/Abstract/Eq, Zafu/Abstract/Ord, Zafu/Abstract/Traverse

Index

• Values: any, concat_all, drop, eq_List, exists, filter, flat_map, foldl, foldr, for_all, get_List, get_or, head, is_empty, last, map, ord_List, set_List, size, sort, split_at, sum, sumf, take, traverse_List, uncons, zip

Values

any

references: Bool, List

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

concat_all

references: List

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

drop

references: Int, List

def drop[a](items: List[a], size: Int) -> List[a]

eq_List

references: List, Zafu/Abstract/Eq::Eq

def eq_List[a](eq_item: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[List[a]]

exists

references: Bool, List

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

filter

references: Bool, List

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

flat_map

references: List

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

foldl

references: List

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

foldr

references: List

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

for_all

references: Bool, List

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

get_List

references: Int, List, Option

def get_List[a](items: List[a], idx: Int) -> Option[a]

get_or

references: Int, List, Unit

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

head

references: List, Option

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

is_empty

references: Bool, List

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

last

references: List, Option

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

map

references: List

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

ord_List

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

def ord_List[a](ord_item: Zafu/Abstract/Ord::Ord[a]) -> Zafu/Abstract/Ord::Ord[List[a]]

set_List

references: Int, List, Option

def set_List[a](items: List[a], idx: Int, value: a) -> Option[List[a]]

size

references: Int, List

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

sort

references: List, Order

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

split_at

references: Int, List, Tuple2

def split_at[a](items: List[a], size: Int) -> (List[a], List[a])

sum

references: Int, List

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

sumf

references: Float64, List

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

take

references: Int, List

def take[a](items: List[a], size: Int) -> List[a]

traverse_List

references: List, Zafu/Abstract/Traverse::Traverse

traverse_List: Zafu/Abstract/Traverse::Traverse[List]

uncons

references: List, Option, Tuple2

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

zip

references: List, Tuple2

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