NAME

       sets - Functions for set manipulation.

DESCRIPTION

       Sets are collections of elements with no duplicate elements.

       The  data  representing  a set as used by this module is to be regarded as opaque by other
       modules. In abstract terms, the representation is a  composite  type  of  existing  Erlang
       terms.  See  note  on  data types. Any code assuming knowledge of the format is running on
       thin ice.

       This module provides the same interface as the ordsets(3erl) module but with an  undefined
       representation.  One  difference  is  that  while  this  module  considers two elements as
       different if they do not match (=:=), ordsets considers two elements as different  if  and
       only if they do not compare equal (==).

       Erlang/OTP  24.0  introduced  a  new  internal  representation  for  sets  which  is  more
       performant. Developers can use this new representation by passing the {version, 2} flag to
       new/1  and  from_list/2,  such  as  sets:new([{version, 2}]). This new representation will
       become the default in future Erlang/OTP versions. Functions that work on two sets, such as
       union/2 and similar, will work with sets of different versions. In such cases, there is no
       guarantee about the version of the returned set. Explicit conversion from the old  version
       to the new one can be done with sets:from_list(sets:to_list(Old), [{version,2}]).

DATA TYPES

       set(Element)

              As returned by new/0.

       set() = set(term())

EXPORTS

       add_element(Element, Set1) -> Set2

              Types:

                 Set1 = Set2 = set(Element)

              Returns a new set formed from Set1 with Element inserted.

       del_element(Element, Set1) -> Set2

              Types:

                 Set1 = Set2 = set(Element)

              Returns Set1, but with Element removed.

       filter(Pred, Set1) -> Set2

              Types:

                 Pred = fun((Element) -> boolean())
                 Set1 = Set2 = set(Element)

              Filters elements in Set1 with boolean function Pred.

       fold(Function, Acc0, Set) -> Acc1

              Types:

                 Function = fun((Element, AccIn) -> AccOut)
                 Set = set(Element)
                 Acc0 = Acc1 = AccIn = AccOut = Acc

              Folds  Function  over  every  element  in  Set  and  returns the final value of the
              accumulator. The evaluation order is undefined.

       from_list(List) -> Set

              Types:

                 List = [Element]
                 Set = set(Element)

              Returns a set of the elements in List.

       from_list(List, Opts :: [{version, 1..2}]) -> Set

              Types:

                 List = [Element]
                 Set = set(Element)

              Returns a set of the elements in List at the given version.

       intersection(SetList) -> Set

              Types:

                 SetList = [set(Element), ...]
                 Set = set(Element)

              Returns the intersection of the non-empty list of sets.

       intersection(Set1, Set2) -> Set3

              Types:

                 Set1 = Set2 = Set3 = set(Element)

              Returns the intersection of Set1 and Set2.

       is_disjoint(Set1, Set2) -> boolean()

              Types:

                 Set1 = Set2 = set(Element)

              Returns true if Set1 and Set2 are disjoint (have no elements in common),  otherwise
              false.

       is_element(Element, Set) -> boolean()

              Types:

                 Set = set(Element)

              Returns true if Element is an element of Set, otherwise false.

       is_empty(Set) -> boolean()

              Types:

                 Set = set()

              Returns true if Set is an empty set, otherwise false.

       is_set(Set) -> boolean()

              Types:

                 Set = term()

              Returns true if Set appears to be a set of elements, otherwise false. Note that the
              test is shallow and will return true for any term that coincides with the  possible
              representations of a set. See also note on data types.

       is_subset(Set1, Set2) -> boolean()

              Types:

                 Set1 = Set2 = set(Element)

              Returns true when every element of Set1 is also a member of Set2, otherwise false.

       new() -> set()

              Returns a new empty set.

       new(Opts :: [{version, 1..2}]) -> set()

              Returns a new empty set at the given version.

       size(Set) -> integer() >= 0

              Types:

                 Set = set()

              Returns the number of elements in Set.

       subtract(Set1, Set2) -> Set3

              Types:

                 Set1 = Set2 = Set3 = set(Element)

              Returns only the elements of Set1 that are not also elements of Set2.

       to_list(Set) -> List

              Types:

                 Set = set(Element)
                 List = [Element]

              Returns  the  elements  of  Set  as  a  list. The order of the returned elements is
              undefined.

       union(SetList) -> Set

              Types:

                 SetList = [set(Element)]
                 Set = set(Element)

              Returns the merged (union) set of the list of sets.

       union(Set1, Set2) -> Set3

              Types:

                 Set1 = Set2 = Set3 = set(Element)

              Returns the merged (union) set of Set1 and Set2.

SEE ALSO

       gb_sets(3erl), ordsets(3erl)