xb5_sets_node (xb5 v1.0.1)

View Source

API for operating over xb5_sets internal nodes directly.

ℹ️ You're likely looking for xb5_sets.





























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
difference/4
does_root_look_legit/2
elixir_reduce(Fun, Acc, Root)
filtermap_to_list/2
fold/3
from_ordset/2
insert_att/2
intersection(Size1, Root1, Size2, Root2)
is_disjoint(Size1, Root1, Size2, Root2)
is_equal(Size1, Root1, Size2, Root2)
is_member/2
is_subset/4
iterator/2
iterator_from/3
larger/2
largest/1
map_to_list/2
new()
next/1
singleton(Elem)
smaller/2
smallest/1
structural_stats(Root)
take_largest/1
take_smallest/1
to_list/1
to_rev_list/1
union/4

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).

difference/4

-spec difference(non_neg_integer(), t(Elem1), non_neg_integer(), t(_)) ->
                    nonempty_improper_list(NewSize :: non_neg_integer(), NewRoot :: t(Elem1)).

does_root_look_legit/2

-spec does_root_look_legit(term(), term()) -> boolean().

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).

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_ordset/2

-spec from_ordset(non_neg_integer(), ordsets:ordset(Elem)) -> t(Elem).

insert_att/2

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

intersection(Size1, Root1, Size2, Root2)

-spec intersection(non_neg_integer(), t(Elem1), non_neg_integer(), t(Elem2)) ->
                      nonempty_improper_list(NewSize :: non_neg_integer(), t(Elem1 | Elem2)).

is_disjoint(Size1, Root1, Size2, Root2)

-spec is_disjoint(non_neg_integer(), t(_), non_neg_integer(), t(_)) -> boolean().

is_equal(Size1, Root1, Size2, Root2)

-spec is_equal(non_neg_integer(), t(_), non_neg_integer(), t(_)) -> boolean().

is_member/2

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

is_subset/4

-spec is_subset(non_neg_integer(), t(_), non_neg_integer(), t(_)) -> boolean().

iterator/2

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

iterator_from/3

-spec iterator_from(_, t(Elem), ordered | reversed) -> 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].

new()

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

next/1

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

singleton(Elem)

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

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].

to_rev_list/1

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

union/4

-spec union(Size1, t(Elem1), Size2, t(Elem2)) -> nonempty_improper_list(NewSize, t(Elem1 | Elem2))
               when Size1 :: non_neg_integer(), Size2 :: non_neg_integer(), NewSize :: non_neg_integer().