Go to main content

man pages section 3: Extended Library Functions, Volume 1

Exit Print View

Updated: Wednesday, July 27, 2022
 
 

sets (3erl)

Name

sets - Functions for set manipulation.

Synopsis

Please see following description for synopsis

Description

sets(3)                    Erlang Module Definition                    sets(3)



NAME
       sets - Functions for set manipulation.

DESCRIPTION
       Sets are collections of elements with no duplicate elements. The repre-
       sentation of a set is undefined.

       This module provides the same interface as the  ordsets(3)  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 pass-
       ing  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 is a set of elements, otherwise false.

       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(3), ordsets(3)



Ericsson AB                       stdlib 3.17                          sets(3)