## table of contents

- bookworm 1:25.2.3+dfsg-1
- testing 1:25.3.2.8+dfsg-1
- unstable 1:25.3.2.11+dfsg-1
- experimental 1:26.2.4+dfsg-1

sets(3erl) | Erlang Module Definition | sets(3erl) |

# 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:

Returns a new set formed from *Set1* with *Element*
inserted.

del_element(Element, Set1) -> Set2

Types:

Returns *Set1*, but with *Element* removed.

filter(Pred, Set1) -> Set2

Types:

Set1 = Set2 = set(Element)

Filters elements in *Set1* with boolean function
*Pred*.

fold(Function, Acc0, Set) -> Acc1

Types:

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:

Set = set(Element)

Returns a set of the elements in *List*.

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

Types:

Set = set(Element)

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

intersection(SetList) -> Set

Types:

Set = set(Element)

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

intersection(Set1, Set2) -> Set3

Types:

Returns the intersection of *Set1* and *Set2*.

is_disjoint(Set1, Set2) -> boolean()

Types:

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

is_element(Element, Set) -> boolean()

Types:

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

is_empty(Set) -> boolean()

Types:

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

is_set(Set) -> boolean()

Types:

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:

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:

Returns the number of elements in *Set*.

subtract(Set1, Set2) -> Set3

Types:

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

to_list(Set) -> List

Types:

List = [Element]

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

union(SetList) -> Set

Types:

Set = set(Element)

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

union(Set1, Set2) -> Set3

Types:

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

# SEE ALSO¶

*gb_sets(3erl)*, *ordsets(3erl)*

stdlib 4.2 | Ericsson AB |