datastructures v0.1.1 Data.Seq

Summary

Types

Functions

all?(sequence, fun \\ fn x -> x end)

Specs

all?(t, (any -> boolean)) :: boolean
any?(sequence, fun \\ fn x -> x end)

Specs

any?(t, (any -> as_boolean(any))) :: boolean
at(sequence, index, default \\ nil)

Specs

at(t, non_neg_integer, any) :: any
contains?(sequence, value, fun \\ fn x -> x end)

Specs

contains?(t, any, (any -> any)) :: boolean
count(sequence)

Specs

count(t) :: non_neg_integer
count(sequence, predicate)

Specs

count(t, (any -> boolean)) :: non_neg_integer
drop(sequence, count)

Specs

drop(t, non_neg_integer) :: t
drop_while(sequence, fun)

Specs

drop_while(t, (any -> as_boolean(term))) :: t
each(sequence, fun)

Specs

each(t, (any -> none)) :: none
empty?(sequence)

Specs

empty?(t) :: boolean
find(sequence, if_none \\ nil, fun)

Specs

find(t, any, (any -> as_boolean(any))) :: any
find_index(sequence, fun)

Specs

find_index(t, (any -> as_boolean(any))) :: any
find_value(sequence, if_none \\ nil, fun)

Specs

find_value(t, any, (any -> any)) :: any
first(sequence)
group_by(seq, into \\ [], fun)

Specs

group_by(t, Data.Dict.t, (term -> term)) :: Data.Dict.t
join(seq, string)

Specs

join(t, String.t) :: String.t
last(sequence)

Specs

last(t) :: term
map(sequence, fun)

Specs

map(t, (any -> any)) :: t
max(sequence)

Specs

max(t) :: any
max(sequence, fun)

Specs

max(t, (any -> any)) :: any
min(sequence)

Specs

min(t) :: any
min(sequence, fun)

Specs

min(t, (any -> any)) :: any
next(sequence)
reduce(sequence, fun)

Specs

reduce(t, (any, any -> any)) :: any
reduce(sequence, acc, fun)

Specs

reduce(t, any, (any, any -> any)) :: any
reject(sequence, fun)

Specs

reject(t, (any -> as_boolean(term))) :: t
reverse(sequence)

Specs

reverse(t) :: t
select(sequence, fun)

Specs

select(t, (any -> as_boolean(term))) :: t
sort(sequence)

Specs

sort(t) :: t
sort(sequence, fun)

Specs

sort(t, (any, any -> boolean)) :: t
split(seq, count)

Specs

split(t, integer) :: {[term], [term]}
take(sequence, count)

Specs

take(t, non_neg_integer) :: t
take_while(sequence, fun)

Specs

take_while(t, (any -> as_boolean(any))) :: t
to_list(sequence)

Specs

to_list(t) :: list
uniq(sequence, fun \\ fn x -> x end)

Specs

uniq(t, (any -> any)) :: t
with_index(sequence)
zip(sequence1, sequence2)

Specs

zip(t, t) :: t