xb5_bag_node (xb5 v1.0.1)

View Source

API for operating over xb5_bag internal nodes directly.

ℹ️ You're likely looking for xb5_bag.





























Summary

Types

elixir_reducer(Elem, ElemAcc)
elixir_reducer_acc(ElemAcc)
elixir_reducer_continuation(ElemAcc)
elixir_reducer_result(ElemAcc)
iter(Elem)
t(Elem)
take_result(Elem)

Functions

delete_att/2
elixir_reduce(Fun, Acc, Root)
elixir_slice(StartIndex, Length, Step, RootSize, Root)
filtermap_to_list/2
fold/3
from_ordered_list/2
insert_att/2
is_member/2
iterator/2
iterator_from/3
iterator_from_nth/4
larger/2
largest/1
map_to_list/2
merge/4
new()
next/1
nth/2
nth_and_nthp1/2
push/2
rank/2
rank_larger/2
rank_smaller/2
smaller/2
smallest/1
structural_stats(Root)
take_largest/1
take_smallest/1
to_list/1

Types

elixir_reducer(Elem, ElemAcc)

-type elixir_reducer(Elem, ElemAcc) :: fun((Elem, ElemAcc) -> elixir_reducer_acc(ElemAcc)).

elixir_reducer_acc(ElemAcc)

-type elixir_reducer_acc(ElemAcc) :: {cont, ElemAcc} | {halt, ElemAcc} | {suspend, ElemAcc}.

elixir_reducer_continuation(ElemAcc)

-type elixir_reducer_continuation(ElemAcc) ::
          fun((elixir_reducer_acc(ElemAcc)) -> elixir_reducer_result(ElemAcc)).

elixir_reducer_result(ElemAcc)

-type elixir_reducer_result(ElemAcc) ::
          {done, ElemAcc} |
          {halted, ElemAcc} |
          {suspended, ElemAcc, elixir_reducer_continuation(ElemAcc)}.

iter(Elem)

-opaque iter(Elem)

t(Elem)

-opaque t(Elem)

take_result(Elem)

-type take_result(Elem) :: nonempty_improper_list(Elem, t(Elem)).

Functions

delete_att/2

-spec delete_att(_, t(Elem)) -> badkey | t(Elem).

elixir_reduce(Fun, Acc, Root)

-spec elixir_reduce(Fun, Acc, Root) -> Result
                       when
                           Fun :: elixir_reducer(Elem, ElemAcc),
                           Acc :: elixir_reducer_acc(ElemAcc),
                           Root :: t(Elem),
                           Result :: elixir_reducer_result(ElemAcc).

elixir_slice(StartIndex, Length, Step, RootSize, Root)

-spec elixir_slice(StartIndex, Length, Step, non_neg_integer(), t(Elem)) -> [Elem]
                      when
                          StartIndex :: non_neg_integer(),
                          Length :: pos_integer(),
                          Step :: pos_integer().

filtermap_to_list/2

-spec filtermap_to_list(fun((Elem) -> {true, MappedElem} | boolean()), t(Elem)) -> [MappedElem].

fold/3

-spec fold(fun((Elem, Acc1) -> Acc2), Acc0, t(Elem)) -> AccN
              when Acc0 :: term(), Acc1 :: term(), Acc2 :: term(), AccN :: term().

from_ordered_list/2

-spec from_ordered_list(non_neg_integer(), [Elem]) -> t(Elem).

insert_att/2

-spec insert_att(NewElem, t(PrevElem)) -> key_exists | t(NewElem | PrevElem).

is_member/2

-spec is_member(_, t(_)) -> boolean().

iterator/2

-spec iterator(t(Elem), ordered | reversed) -> iter(Elem).

iterator_from/3

-spec iterator_from(_, t(Elem), ordered | reversed) -> iter(Elem).

iterator_from_nth/4

-spec iterator_from_nth(pos_integer(), non_neg_integer(), t(Elem), ordered) -> iter(Elem).

larger/2

-spec larger(_, t(Elem)) -> {found, Elem} | none.

largest/1

-spec largest(t(Elem)) -> Elem.

map_to_list/2

-spec map_to_list(fun((Elem) -> MappedElem), t(Elem)) -> [MappedElem].

merge/4

-spec merge(non_neg_integer(), t(Elem1), non_neg_integer(), t(Elem2)) -> t(Elem1 | Elem2).

new()

-spec new() -> t(_).

next/1

-spec next(iter(Elem)) -> {Elem, iter(Elem)} | none.

nth/2

-spec nth(pos_integer(), t(E)) -> E.

nth_and_nthp1/2

-spec nth_and_nthp1(pos_integer(), t(E)) -> nonempty_improper_list(E, E).

push/2

-spec push(NewElem, t(PrevElem)) -> t(NewElem | PrevElem).

rank/2

-spec rank(_, t(_)) -> pos_integer() | none.

rank_larger/2

-spec rank_larger(_, t(E)) -> nonempty_improper_list(pos_integer(), E) | none.

rank_smaller/2

-spec rank_smaller(_, t(E)) -> nonempty_improper_list(pos_integer(), E) | none.

smaller/2

-spec smaller(_, t(Elem)) -> {found, Elem} | none.

smallest/1

-spec smallest(t(Elem)) -> Elem.

structural_stats(Root)

-spec structural_stats(t(_)) -> xb5_structural_stats:t().

take_largest/1

-spec take_largest(t(Elem)) -> take_result(Elem).

take_smallest/1

-spec take_smallest(t(Elem)) -> take_result(Elem).

to_list/1

-spec to_list(t(Elem)) -> [Elem].