Module sets

Data Types
Function Index
Function Details

Data Types

set()

abstract datatype: set(Element)

set()


set() = set(term())

Function Index

add_element/2	Return `Set1` with `Element` inserted in it.
del_element/2	Return `Set1` but with `Element` removed.
filter/2	Filter Set with Fun.
filtermap/2	Filters and maps elements in `Set1` with function `Fun`.
fold/3	Fold function Fun over all elements in Set and return Accumulator.
from_list/1	Builds a set from the elements in `List`.
from_list/2	Builds a set from the elements in `List` using the specified version.
intersection/1	Return the intersection of the list of sets.
intersection/2	Return the intersection of `Set1` and `Set2`.
is_disjoint/2	Check whether `Set1` and `Set2` are disjoint.
is_element/2	Return `true` if `Element` is an element of `Set`, else `false`.
is_empty/1	Returns `true` if `Set` is an empty set, otherwise `false`.
is_equal/2	Returns `true` if `Set1` and `Set2` are equal, that is when every element of one set is also a member of the respective other set, otherwise `false`.
is_set/1	Returns `true` if `Set` appears to be a set of elements, otherwise `false`.
is_subset/2	Return 'true' when every element of Set1 is also a member of Set2, else 'false'.
map/2	Map Set with Fun.
new/0	Returns a new empty set using the v2 format (a map).
new/1	Returns a new empty set (only v2 format is supported).
size/1	Returns the number of elements in `Set`.
subtract/2	Return all and only the elements of Set1 which are not also in Set2.
to_list/1	Returns the elements of `Set` as a list.
union/1	Return the union of the list of sets.
union/2	Return the union of `Set1` and `Set2`.

Function Details

add_element/2


add_element(Element, Set1) -> Set2

Set1 = set(Element)
Set2 = set(Element)

Element: the element to add
Set1: the set to add the element to

returns: Returns a new set formed from Set1 with Element inserted.

Return Set1 with Element inserted in it.

del_element/2


del_element(Element, Set1) -> Set2

Set1 = set(Element)
Set2 = set(Element)

Element: the element to remove
Set1: the set to remove the element from

returns: Returns Set1, but with Element removed.

Return Set1 but with Element removed.

filter/2


filter(Pred, Set1) -> Set2

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

Pred: the boolean function to filter elements with
Set1: the set to filter

returns: Returns a set containing elements of Set1 that satisfy the boolean function Fun. The evaluation order is undefined.

Filter Set with Fun.

filtermap/2


filtermap(Fun, Set1) -> Set2

Fun = fun((Element1) -> boolean() | {true, Element2})
Set1 = set(Element1)
Set2 = set(Element1 | Element2)

Fun: the filter and map fun
Set1: the set to filter and map over

returns: Returns a set containing elements of Set1 that are filtered and mapped using Fun.

Filters and maps elements in Set1 with function Fun.

fold/3


fold(Function, Acc0, Set) -> Acc1

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

Set: the set to fold over

returns: Returns the final value of the accumulator after folding the function over every element in the set.

Fold function Fun over all elements in Set and return Accumulator.

from_list/1


from_list(List) -> Set

List = [Element]
Set = set(Element)

List: the list of items that is used for building the set

returns: Returns a set of the elements in List.

Builds a set from the elements in List.

from_list/2


from_list(List, Version::[{version, 2}]) -> Set

List = [Element]
Set = set(Element)

List: the list to be converted to a set
Version: only version 2 is supported

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

Builds a set from the elements in List using the specified version. Only v2 format is supported.

intersection/1


intersection(SetList) -> Set

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

SetList: the non-empty list of sets

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

Return the intersection of the list of sets.

intersection/2


intersection(Set1, Set2) -> Set3

Set1 = set(Element)
Set2 = set(Element)
Set3 = set(Element)

Set1: the first set
Set2: the second set

returns: Returns the intersection of Set1 and Set2.

Return the intersection of Set1 and Set2.

is_disjoint/2


is_disjoint(Set1, Set2) -> boolean()

Set1 = set(Element)
Set2 = set(Element)

Set1: the first set
Set2: the second set

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

Check whether Set1 and Set2 are disjoint.

is_element/2


is_element(Element, Set) -> boolean()

Set = set(Element)

Element: the element to check
Set: the set to check against

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

Return true if Element is an element of Set, else false.

is_empty/1


is_empty(Set) -> boolean()

Set = set()

Set: the set to be checked for emptiness

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

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

is_equal/2


is_equal(Set1, Set2) -> boolean()

Set1 = set()
Set2 = set()

Set1: first set to be checked for equality
Set2: second set to be checked for equality

returns: Return true if Set1 and Set2 contain the same elements, otherwise false.

Returns true if Set1 and Set2 are equal, that is when every element of one set is also a member of the respective other set, otherwise false.

is_set/1


is_set(Set) -> boolean()

Set = term()

Set: the term that will be checked

returns: Return true if Set is a set of elements, else false.

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.

is_subset/2


is_subset(Set1, Set2) -> boolean()

Set1 = set(Element)
Set2 = set(Element)

Set1: the first set
Set2: the second set

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

Return ‘true’ when every element of Set1 is also a member of Set2, else ‘false’.

map/2


map(Fun, Set1) -> Set2

Fun = fun((Element1) -> Element2)
Set1 = set(Element1)
Set2 = set(Element2)

Fun: the mapping function
Set1: the set to map over

returns: Returns a set containing elements of Set1 that are mapped using Fun.

Map Set with Fun.

new/0


new() -> set(none())

returns: Returns a new empty set.

Returns a new empty set using the v2 format (a map).

new/1


new(Version::[{version, 2}]) -> set(none())

Version: must be {version, 2}

returns: Returns a new empty set.

Returns a new empty set (only v2 format is supported).

size/1


size(Set) -> non_neg_integer()

Set = set()

Set: the set for which size will be returned

returns: Return the number of elements in Set.

Returns the number of elements in Set.

subtract/2


subtract(Set1, Set2) -> Set3

Set1 = set(Element)
Set2 = set(Element)
Set3 = set(Element)

Set1: the first set
Set2: the second set

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

Return all and only the elements of Set1 which are not also in Set2.

to_list/1


to_list(Set) -> List

Set = set(Element)
List = [Element]

Set: the set to be converted to a list

returns: Return the elements in Set as a list.

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

union/1


union(SetList) -> Set

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

SetList: the list of sets

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

Return the union of the list of sets.

union/2


union(Set1, Set2) -> Set3

Set1 = set(Element)
Set2 = set(Element)
Set3 = set(Element)

Set1: the first set
Set2: the second set

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

Return the union of Set1 and Set2.