gleam_stdlib - v0.70.0

gleam/set

Types

Set

opaque </>

A set is a collection of unique members of the same type.

It is implemented using the gleam/dict module, so inserts and lookups have logarithmic time complexity.

pub opaque type Set(member)

Values

contains

</> 
pub fn contains(in set: Set(member), this member: member) -> Bool

Checks whether a set contains a given member.

This function runs in logarithmic time.

Examples

assert new()
  |> insert(2)
  |> contains(2)

assert !{
  new()
  |> insert(2)
  |> contains(1)
}

delete

</> 
pub fn delete(
  from set: Set(member),
  this member: member,
) -> Set(member)

Removes a member from a set. If the set does not contain the member then the set is returned unchanged.

This function runs in logarithmic time.

Examples

assert !{
  new()
  |> insert(2)
  |> delete(2)
  |> contains(2)
}

difference

</> 
pub fn difference(
  from first: Set(member),
  minus second: Set(member),
) -> Set(member)

Creates a new set that contains members that are present in the first set but not the second.

Examples

assert difference(from_list([1, 2]), from_list([2, 3, 4])) |> to_list
  == [1]

drop

</> 
pub fn drop(
  from set: Set(member),
  drop disallowed: List(member),
) -> Set(member)

Creates a new set from a given set with all the same entries except any entry found on the given list.

Examples

assert from_list([1, 2, 3, 4])
  |> drop([1, 3])
  |> to_list
  == [2, 4]

each

</> 
pub fn each(set: Set(member), fun: fn(member) -> a) -> Nil

Calls a function for each member in a set, discarding the return value.

Useful for producing a side effect for every item of a set.

The order of elements in the iteration is an implementation detail that should not be relied upon.

Examples

let set = from_list(["apple", "banana", "cherry"])

assert each(set, io.println) == Nil
// apple
// banana
// cherry

filter

</> 
pub fn filter(
  in set: Set(member),
  keeping predicate: fn(member) -> Bool,
) -> Set(member)

Creates a new set from an existing set, minus any members that a given function returns False for.

This function runs in loglinear time.

Examples

import gleam/int

assert from_list([1, 4, 6, 3, 675, 44, 67])
  |> filter(keeping: int.is_even)
  |> to_list
  == [4, 6, 44]

fold

</> 
pub fn fold(
  over set: Set(member),
  from initial: acc,
  with reducer: fn(acc, member) -> acc,
) -> acc

Combines all entries into a single value by calling a given function on each one.

Sets are not ordered so the values are not returned in any specific order. Do not write code that relies on the order entries are used by this function as it may change in later versions of Gleam or Erlang.

Examples

assert from_list([1, 3, 9])
  |> fold(0, fn(accumulator, member) { accumulator + member })
  == 13

from_list

</> 
pub fn from_list(members: List(member)) -> Set(member)

Creates a new set of the members in a given list.

This function runs in loglinear time.

Examples

import gleam/int
import gleam/list

assert [1, 1, 2, 4, 3, 2]
  |> from_list
  |> to_list
  |> list.sort(by: int.compare)
  == [1, 2, 3, 4]

insert

</> 
pub fn insert(
  into set: Set(member),
  this member: member,
) -> Set(member)

Inserts a member into the set.

This function runs in logarithmic time.

Examples

assert new()
  |> insert(1)
  |> insert(2)
  |> size
  == 2

intersection

</> 
pub fn intersection(
  of first: Set(member),
  and second: Set(member),
) -> Set(member)

Creates a new set that contains members that are present in both given sets.

This function runs in loglinear time.

Examples

assert intersection(from_list([1, 2]), from_list([2, 3])) |> to_list
  == [2]

is_disjoint

</> 
pub fn is_disjoint(
  first: Set(member),
  from second: Set(member),
) -> Bool

Determines if two sets contain no common members

Examples

assert is_disjoint(from_list([1, 2, 3]), from_list([4, 5, 6]))

assert !is_disjoint(from_list([1, 2, 3]), from_list([3, 4, 5]))

is_empty

</> 
pub fn is_empty(set: Set(member)) -> Bool

Determines whether or not the set is empty.

Examples

assert new() |> is_empty

assert !{ new() |> insert(1) |> is_empty }

is_subset

</> 
pub fn is_subset(
  first: Set(member),
  of second: Set(member),
) -> Bool

Determines if a set is fully contained by another.

Examples

assert is_subset(from_list([1]), from_list([1, 2]))

assert !is_subset(from_list([1, 2, 3]), from_list([3, 4, 5]))

map

</> 
pub fn map(
  set: Set(member),
  with fun: fn(member) -> mapped,
) -> Set(mapped)

Creates a new set from a given set with the result of applying the given function to each member.

Examples

assert from_list([1, 2, 3, 4])
  |> map(with: fn(x) { x * 2 })
  |> to_list
  == [2, 4, 6, 8]

new

</> 
pub fn new() -> Set(member)

Creates a new empty set.

size

</> 
pub fn size(set: Set(member)) -> Int

Gets the number of members in a set.

This function runs in constant time.

Examples

assert new()
  |> insert(1)
  |> insert(2)
  |> size
  == 2

symmetric_difference

</> 
pub fn symmetric_difference(
  of first: Set(member),
  and second: Set(member),
) -> Set(member)

Creates a new set that contains members that are present in either set, but not both.

Examples

assert symmetric_difference(from_list([1, 2, 3]), from_list([3, 4]))
  |> to_list
  == [1, 2, 4]

take

</> 
pub fn take(
  from set: Set(member),
  keeping desired: List(member),
) -> Set(member)

Creates a new set from a given set, only including any members which are in a given list.

This function runs in loglinear time.

Examples

assert from_list([1, 2, 3])
  |> take([1, 3, 5])
  |> to_list
  == [1, 3]

to_list

</> 
pub fn to_list(set: Set(member)) -> List(member)

Converts the set into a list of the contained members.

The list has no specific ordering, any unintentional ordering may change in future versions of Gleam or Erlang.

This function runs in linear time.

Examples

assert new() |> insert(2) |> to_list == [2]

union

</> 
pub fn union(
  of first: Set(member),
  and second: Set(member),
) -> Set(member)

Creates a new set that contains all members of both given sets.

This function runs in loglinear time.

Examples

assert union(from_list([1, 2]), from_list([2, 3])) |> to_list
  == [1, 2, 3]
✨ Search Document