# Elixir v1.10.3 MapSet View Source

Functions that work on sets.

A set is a data structure that can contain unique elements of any kind, without any particular order. `MapSet` is the "go to" set data structure in Elixir.

A set can be constructed using `MapSet.new/0`:

    iex> MapSet.new()
    #MapSet<[]>

Elements in a set don't have to be of the same type and they can be populated from an enumerable using `MapSet.new/1`:

    iex> MapSet.new([1, :two, {"three"}])
    #MapSet<[1, :two, {"three"}]>

Elements can be inserted using `MapSet.put/2`:

    iex> MapSet.new([2]) |> MapSet.put(4) |> MapSet.put(0)
    #MapSet<[0, 2, 4]>

By definition, sets can't contain duplicate elements: when inserting an element in a set where it's already present, the insertion is simply a no-op.

    iex> map_set = MapSet.new()
    iex> MapSet.put(map_set, "foo")
    #MapSet<["foo"]>
    iex> map_set |> MapSet.put("foo") |> MapSet.put("foo")
    #MapSet<["foo"]>

A `MapSet` is represented internally using the `%MapSet{}` struct. This struct can be used whenever there's a need to pattern match on something being a `MapSet`:

    iex> match?(%MapSet{}, MapSet.new())
    true

Note that, however, the struct fields are private and must not be accessed directly; use the functions in this module to perform operations on sets.

`MapSet`s can also be constructed starting from other collection-type data structures: for example, see `MapSet.new/1` or `Enum.into/2`.

`MapSet` is built on top of `Map`, this means that they share many properties, including logarithmic time complexity. See the documentation for `Map` for more information on its execution time complexity.

# Link to this section Summary

## Types

t()
t(value)
value()

## Functions

delete(map_set, value)

Deletes `value` from `map_set`.

difference(map_set1, map_set2)

Returns a set that is `map_set1` without the members of `map_set2`.

disjoint?(map_set1, map_set2)

Checks if `map_set1` and `map_set2` have no members in common.

equal?(map_set1, map_set2)

Checks if two sets are equal.

intersection(map_set, map_set)

Returns a set containing only members that `map_set1` and `map_set2` have in common.

member?(map_set, value)

Checks if `map_set` contains `value`.

new()

Returns a new set.

new(enumerable)

Creates a set from an enumerable.

new(enumerable, transform)

Creates a set from an enumerable via the transformation function.

put(map_set, value)

Inserts `value` into `map_set` if `map_set` doesn't already contain it.

size(map_set)

Returns the number of elements in `map_set`.

subset?(map_set1, map_set2)

Checks if `map_set1`'s members are all contained in `map_set2`.

to_list(map_set)

Converts `map_set` to a list.

union(map_set1, map_set2)

Returns a set containing all members of `map_set1` and `map_set2`.

# Link to this section Types

Link to this type

# t()

View Source

## Specs

    t() :: t(term())

Link to this opaque

# t(value)

View Source (opaque)

## Specs

    t(value)

Link to this type

# value()

View Source

## Specs

    value() :: term()

# Link to this section Functions

Link to this function

# delete(map_set, value)

View Source

## Specs

    delete(t(val1), val2) :: t(val1) when val1: value(), val2: value()

Deletes `value` from `map_set`.

Returns a new set which is a copy of `map_set` but without `value`.

## Examples

    iex> map_set = MapSet.new([1, 2, 3])
    iex> MapSet.delete(map_set, 4)
    #MapSet<[1, 2, 3]>
    iex> MapSet.delete(map_set, 2)
    #MapSet<[1, 3]>

Link to this function

# difference(map_set1, map_set2)

View Source

## Specs

    difference(t(val1), t(val2)) :: t(val1) when val1: value(), val2: value()

Returns a set that is `map_set1` without the members of `map_set2`.

## Examples

    iex> MapSet.difference(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
    #MapSet<[1]>

Link to this function

# disjoint?(map_set1, map_set2)

View Source

## Specs

    disjoint?(t(), t()) :: boolean()

Checks if `map_set1` and `map_set2` have no members in common.

## Examples

    iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([3, 4]))
    true
    iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([2, 3]))
    false

Link to this function

# equal?(map_set1, map_set2)

View Source

## Specs

    equal?(t(), t()) :: boolean()

Checks if two sets are equal.

The comparison between elements must be done using `===/2`.

## Examples

    iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([2, 1, 1]))
    true
    iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([3, 4]))
    false

Link to this function

# intersection(map_set, map_set)

View Source

## Specs

    intersection(t(val), t(val)) :: t(val) when val: value()

Returns a set containing only members that `map_set1` and `map_set2` have in common.

## Examples

    iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
    #MapSet<[2]>

    iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([3, 4]))
    #MapSet<[]>

Link to this function

# member?(map_set, value)

View Source

## Specs

    member?(t(), value()) :: boolean()

Checks if `map_set` contains `value`.

## Examples

    iex> MapSet.member?(MapSet.new([1, 2, 3]), 2)
    true
    iex> MapSet.member?(MapSet.new([1, 2, 3]), 4)
    false

Link to this function

# new()

View Source

## Specs

    new() :: t()

Returns a new set.

## Examples

    iex> MapSet.new()
    #MapSet<[]>

Link to this function

# new(enumerable)

View Source

## Specs

    new(Enum.t()) :: t()

Creates a set from an enumerable.

## Examples

    iex> MapSet.new([:b, :a, 3])
    #MapSet<[3, :a, :b]>
    iex> MapSet.new([3, 3, 3, 2, 2, 1])
    #MapSet<[1, 2, 3]>

Link to this function

# new(enumerable, transform)

View Source

## Specs

    new(Enum.t(), (term() -> val)) :: t(val) when val: value()

Creates a set from an enumerable via the transformation function.

## Examples

    iex> MapSet.new([1, 2, 1], fn x -> 2 * x end)
    #MapSet<[2, 4]>

Link to this function

# put(map_set, value)

View Source

## Specs

    put(t(val), new_val) :: t(val | new_val) when val: value(), new_val: value()

Inserts `value` into `map_set` if `map_set` doesn't already contain it.

## Examples

    iex> MapSet.put(MapSet.new([1, 2, 3]), 3)
    #MapSet<[1, 2, 3]>
    iex> MapSet.put(MapSet.new([1, 2, 3]), 4)
    #MapSet<[1, 2, 3, 4]>

Link to this function

# size(map_set)

View Source

## Specs

    size(t()) :: non_neg_integer()

Returns the number of elements in `map_set`.

## Examples

    iex> MapSet.size(MapSet.new([1, 2, 3]))
    3

Link to this function

# subset?(map_set1, map_set2)

View Source

## Specs

    subset?(t(), t()) :: boolean()

Checks if `map_set1`'s members are all contained in `map_set2`.

This function checks if `map_set1` is a subset of `map_set2`.

## Examples

    iex> MapSet.subset?(MapSet.new([1, 2]), MapSet.new([1, 2, 3]))
    true
    iex> MapSet.subset?(MapSet.new([1, 2, 3]), MapSet.new([1, 2]))
    false

Link to this function

# to_list(map_set)

View Source

## Specs

    to_list(t(val)) :: [val] when val: value()

Converts `map_set` to a list.

## Examples

    iex> MapSet.to_list(MapSet.new([1, 2, 3]))
    [1, 2, 3]

Link to this function

# union(map_set1, map_set2)

View Source

## Specs

    union(t(val1), t(val2)) :: t(val1 | val2) when val1: value(), val2: value()

Returns a set containing all members of `map_set1` and `map_set2`.

## Examples

    iex> MapSet.union(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
    #MapSet<[1, 2, 3, 4]>