protocol SetAlgebra
A type that provides mathematical set operations.
Inheritance  Equatable, ExpressibleByArrayLiteral 

Conforming Types  OptionSet, Set 
Associated Types 
associatedtype Element

Initializers
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()
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
A Boolean value that indicates whether the set has no elements.
Declaration
var isEmpty: Bool
Instance Methods
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
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)
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)
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)
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)
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
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
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
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
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?
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)
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
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
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
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
Declaration
public static func !=(lhs: Self, rhs: Self) > Bool
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 theSet
type with elements of any hashable type, or you can easily create bit masks withSetAlgebra
conformance using theOptionSet
protocol. See those types for more information.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 thatS
is a custom type that conforms to theSetAlgebra
protocol,x
andy
are instances ofS
, ande
is of typeS.Element
the type that the set holds.