## SetAlgebra

`protocol SetAlgebra`

A type that provides mathematical set operations.

Inheritance `Equatable, ExpressibleByArrayLiteral` `OptionSet, Set` `associatedtype Element`

You use types that conform to the `SetAlgebra` protocol when you need efficient membership tests or mathematical set operations such as intersection, union, and subtraction. In the standard library, you can use the `Set` type with elements of any hashable type, or you can easily create bit masks with `SetAlgebra` conformance using the `OptionSet` protocol. See those types for more information.

Note: Unlike ordinary set types, the `Element` type of an `OptionSet` is identical to the `OptionSet` type itself. The `SetAlgebra` protocol is specifically designed to accommodate both kinds of set.

### Conforming to the SetAlgebra Protocol

When implementing a custom type that conforms to the `SetAlgebra` protocol, you must implement the required initializers and methods. For the inherited methods to work properly, conforming types must meet the following axioms. Assume that `S` is a custom type that conforms to the `SetAlgebra` protocol, `x` and `y` are instances of `S`, and `e` is of type `S.Element`---the type that the set holds.

### Initializers

init init() Required

Creates an empty set.

This initializer is equivalent to initializing with an empty array literal. For example, you create an empty `Set` instance with either this initializer or with an empty array literal.

``````var emptySet = Set<Int>()
print(emptySet.isEmpty)
// Prints "true"

emptySet = []
print(emptySet.isEmpty)
// Prints "true"
``````

#### Declaration

`init()`
init init(_:) Required

Creates a new set from a finite sequence of items.

Use this initializer to create a new set from an existing sequence, like an array or a range:

``````let validIndices = Set(0..<7).subtracting([2, 4, 5])
print(validIndices)
// Prints "[6, 0, 1, 3]"
``````
• Parameter sequence: The elements to use as members of the new set.

#### Declaration

`init<S>(_ sequence: S) where S: Sequence, Self.Element == S.Element`

### Instance Variables

var isEmpty Required

A Boolean value that indicates whether the set has no elements.

#### Declaration

`var isEmpty: Bool`

### Instance Methods

func contains(_ member: Self.Element) -> Bool Required

Returns a Boolean value that indicates whether the given element exists in the set.

This example uses the `contains(_:)` method to test whether an integer is a member of a set of prime numbers.

``````let primes: Set = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
let x = 5
if primes.contains(x) {
print("\(x) is prime!")
} else {
print("\(x). Not prime.")
}
// Prints "5 is prime!"
``````
• Parameter member: An element to look for in the set.

#### Declaration

`func contains(_ member: Self.Element) -> Bool`
func formIntersection(_ other: Self) Required

Removes the elements of this set that aren't also in the given set.

In the following example, the elements of the `employees` set that are not also members of the `neighbors` set are removed. In particular, the names `"Alicia"`, `"Chris"`, and `"Diana"` are removed.

``````var employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"]
employees.formIntersection(neighbors)
print(employees)
// Prints "["Bethany", "Eric"]"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`mutating func formIntersection(_ other: Self)`
func formSymmetricDifference(_ other: Self) Required

Removes the elements of the set that are also in the given set and adds the members of the given set that are not already in the set.

In the following example, the elements of the `employees` set that are also members of `neighbors` are removed from `employees`, while the elements of `neighbors` that are not members of `employees` are added to `employees`. In particular, the names `"Bethany"` and `"Eric"` are removed from `employees` while the name `"Forlani"` is added.

``````var employees: Set = ["Alicia", "Bethany", "Diana", "Eric"]
let neighbors: Set = ["Bethany", "Eric", "Forlani"]
employees.formSymmetricDifference(neighbors)
print(employees)
// Prints "["Diana", "Forlani", "Alicia"]"
``````
• Parameter other: A set of the same type.

#### Declaration

`mutating func formSymmetricDifference(_ other: Self)`
func formUnion(_ other: Self) Required

Adds the elements of the given set to the set.

In the following example, the elements of the `visitors` set are added to the `attendees` set:

``````var attendees: Set = ["Alicia", "Bethany", "Diana"]
let visitors: Set = ["Diana", "Marcia", "Nathaniel"]
attendees.formUnion(visitors)
print(attendees)
// Prints "["Diana", "Nathaniel", "Bethany", "Alicia", "Marcia"]"
``````

If the set already contains one or more elements that are also in `other`, the existing members are kept.

``````var initialIndices = Set(0..<5)
initialIndices.formUnion([2, 3, 6, 7])
print(initialIndices)
// Prints "[2, 4, 6, 7, 0, 1, 3]"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`mutating func formUnion(_ other: Self)`
func insert(_ newMember: Self.Element) -> (inserted: Bool, memberAfterInsert: Self.Element) Required

Inserts the given element in the set if it is not already present.

If an element equal to `newMember` is already contained in the set, this method has no effect. In this example, a new element is inserted into `classDays`, a set of days of the week. When an existing element is inserted, the `classDays` set does not change.

``````enum DayOfTheWeek: Int {
case sunday, monday, tuesday, wednesday, thursday,
friday, saturday
}

var classDays: Set<DayOfTheWeek> = [.wednesday, .friday]
print(classDays.insert(.monday))
// Prints "(true, .monday)"
print(classDays)
// Prints "[.friday, .wednesday, .monday]"

print(classDays.insert(.friday))
// Prints "(false, .friday)"
print(classDays)
// Prints "[.friday, .wednesday, .monday]"
``````
• Parameter newMember: An element to insert into the set.

#### Declaration

`mutating func insert(_ newMember: Self.Element) -> (inserted: Bool, memberAfterInsert: Self.Element)`
func intersection(_ other: Self) -> Self Required

Returns a new set with the elements that are common to both this set and the given set.

In the following example, the `bothNeighborsAndEmployees` set is made up of the elements that are in both the `employees` and `neighbors` sets. Elements that are in only one or the other are left out of the result of the intersection.

``````let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"]
let bothNeighborsAndEmployees = employees.intersection(neighbors)
print(bothNeighborsAndEmployees)
// Prints "["Bethany", "Eric"]"
``````
• Parameter other: A set of the same type as the current set.

Note: if this set and `other` contain elements that are equal but distinguishable (e.g. via `===`), which of these elements is present in the result is unspecified.

#### Declaration

`func intersection(_ other: Self) -> Self`
func isDisjoint(with other: Self) -> Bool Required

Returns a Boolean value that indicates whether the set has no members in common with the given set.

In the following example, the `employees` set is disjoint with the `visitors` set because no name appears in both sets.

``````let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let visitors: Set = ["Marcia", "Nathaniel", "Olivia"]
print(employees.isDisjoint(with: visitors))
// Prints "true"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`func isDisjoint(with other: Self) -> Bool`
func isSubset(of other: Self) -> Bool Required

Returns a Boolean value that indicates whether the set is a subset of another set.

Set A is a subset of another set B if every member of A is also a member of B.

``````let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let attendees: Set = ["Alicia", "Bethany", "Diana"]
print(attendees.isSubset(of: employees))
// Prints "true"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`func isSubset(of other: Self) -> Bool`
func isSuperset(of other: Self) -> Bool Required

Returns a Boolean value that indicates whether the set is a superset of the given set.

Set A is a superset of another set B if every member of B is also a member of A.

``````let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let attendees: Set = ["Alicia", "Bethany", "Diana"]
print(employees.isSuperset(of: attendees))
// Prints "true"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`func isSuperset(of other: Self) -> Bool`
func remove(_ member: Self.Element) -> Self.Element? Required

Removes the given element and any elements subsumed by the given element.

• Parameter member: The element of the set to remove.

#### Declaration

`mutating func remove(_ member: Self.Element) -> Self.Element?`
func subtract(_ other: Self) Required

Removes the elements of the given set from this set.

In the following example, the elements of the `employees` set that are also members of the `neighbors` set are removed. In particular, the names `"Bethany"` and `"Eric"` are removed from `employees`.

``````var employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"]
employees.subtract(neighbors)
print(employees)
// Prints "["Diana", "Chris", "Alicia"]"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`mutating func subtract(_ other: Self)`
func subtracting(_ other: Self) -> Self Required

Returns a new set containing the elements of this set that do not occur in the given set.

In the following example, the `nonNeighbors` set is made up of the elements of the `employees` set that are not elements of `neighbors`:

``````let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"]
let nonNeighbors = employees.subtracting(neighbors)
print(nonNeighbors)
// Prints "["Diana", "Chris", "Alicia"]"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`func subtracting(_ other: Self) -> Self`
func symmetricDifference(_ other: Self) -> Self Required

Returns a new set with the elements that are either in this set or in the given set, but not in both.

In the following example, the `eitherNeighborsOrEmployees` set is made up of the elements of the `employees` and `neighbors` sets that are not in both `employees` and `neighbors`. In particular, the names `"Bethany"` and `"Eric"` do not appear in `eitherNeighborsOrEmployees`.

``````let employees: Set = ["Alicia", "Bethany", "Diana", "Eric"]
let neighbors: Set = ["Bethany", "Eric", "Forlani"]
let eitherNeighborsOrEmployees = employees.symmetricDifference(neighbors)
print(eitherNeighborsOrEmployees)
// Prints "["Diana", "Forlani", "Alicia"]"
``````
• Parameter other: A set of the same type as the current set.

#### Declaration

`func symmetricDifference(_ other: Self) -> Self`
func union(_ other: Self) -> Self Required

Returns a new set with the elements of both this and the given set.

In the following example, the `attendeesAndVisitors` set is made up of the elements of the `attendees` and `visitors` sets:

``````let attendees: Set = ["Alicia", "Bethany", "Diana"]
let visitors = ["Marcia", "Nathaniel"]
let attendeesAndVisitors = attendees.union(visitors)
print(attendeesAndVisitors)
// Prints "["Diana", "Nathaniel", "Bethany", "Alicia", "Marcia"]"
``````

If the set already contains one or more elements that are also in `other`, the existing members are kept.

``````let initialIndices = Set(0..<5)
let expandedIndices = initialIndices.union([2, 3, 6, 7])
print(expandedIndices)
// Prints "[2, 4, 6, 7, 0, 1, 3]"
``````
• Parameter other: A set of the same type as the current set.

Note: if this set and `other` contain elements that are equal but distinguishable (e.g. via `===`), which of these elements is present in the result is unspecified.

#### Declaration

`func union(_ other: Self) -> Self`
func update(with newMember: Self.Element) -> Self.Element? Required

Inserts the given element into the set unconditionally.

If an element equal to `newMember` is already contained in the set, `newMember` replaces the existing element. In this example, an existing element is inserted into `classDays`, a set of days of the week.

``````enum DayOfTheWeek: Int {
case sunday, monday, tuesday, wednesday, thursday,
friday, saturday
}

var classDays: Set<DayOfTheWeek> = [.monday, .wednesday, .friday]
print(classDays.update(with: .monday))
// Prints "Optional(.monday)"
``````
• Parameter newMember: An element to insert into the set.

#### Declaration

`mutating func update(with newMember: Self.Element) -> Self.Element?`

### Default Implementations

func !=(lhs: Self, rhs: Self) -> Bool

#### Declaration

`public static func !=(lhs: Self, rhs: Self) -> Bool`