StructureSwift5.9.0
Set
An unordered collection of unique elements.
@frozen struct Set<Element> where Element : HashableYou use a set instead of an array when you need to test efficiently for membership and you aren’t concerned with the order of the elements in the collection, or when you need to ensure that each element appears only once in a collection.
You can create a set with any element type that conforms to the Hashable protocol. By default, most types in the standard library are hashable, including strings, numeric and Boolean types, enumeration cases without associated values, and even sets themselves.
Swift makes it as easy to create a new set as to create a new array. Simply assign an array literal to a variable or constant with the Set type specified.
let ingredients: Set = ["cocoa beans", "sugar", "cocoa butter", "salt"]
if ingredients.contains("sugar") {
print("No thanks, too sweet.")
}
// Prints "No thanks, too sweet."Set Operations
Sets provide a suite of mathematical set operations. For example, you can efficiently test a set for membership of an element or check its intersection with another set:
Use the
contains(_:)method to test whether a set contains a specific element.Use the “equal to” operator (
==) to test whether two sets contain the same elements.Use the
isSubset(of:)method to test whether a set contains all the elements of another set or sequence.Use the
isSuperset(of:)method to test whether all elements of a set are contained in another set or sequence.Use the
isStrictSubset(of:)andisStrictSuperset(of:)methods to test whether a set is a subset or superset of, but not equal to, another set.Use the
isDisjoint(with:)method to test whether a set has any elements in common with another set.
You can also combine, exclude, or subtract the elements of two sets:
Use the
union(_:)method to create a new set with the elements of a set and another set or sequence.Use the
intersection(_:)method to create a new set with only the elements common to a set and another set or sequence.Use the
symmetricDifference(_:)method to create a new set with the elements that are in either a set or another set or sequence, but not in both.Use the
subtracting(_:)method to create a new set with the elements of a set that are not also in another set or sequence.
You can modify a set in place by using these methods’ mutating counterparts: formUnion(_:), formIntersection(_:), formSymmetricDifference(_:), and subtract(_:).
Set operations are not limited to use with other sets. Instead, you can perform set operations with another set, an array, or any other sequence type.
var primes: Set = [2, 3, 5, 7]
// Tests whether primes is a subset of a Range<Int>
print(primes.isSubset(of: 0..<10))
// Prints "true"
// Performs an intersection with an Array<Int>
let favoriteNumbers = [5, 7, 15, 21]
print(primes.intersection(favoriteNumbers))
// Prints "[5, 7]"Sequence and Collection Operations
In addition to the Set type’s set operations, you can use any nonmutating sequence or collection methods with a set.
if primes.isEmpty {
print("No primes!")
} else {
print("We have \(primes.count) primes.")
}
// Prints "We have 4 primes."
let primesSum = primes.reduce(0, +)
// 'primesSum' == 17
let primeStrings = primes.sorted().map(String.init)
// 'primeStrings' == ["2", "3", "5", "7"]You can iterate through a set’s unordered elements with a for-in loop.
for number in primes {
print(number)
}
// Prints "5"
// Prints "7"
// Prints "2"
// Prints "3"Many sequence and collection operations return an array or a type-erasing collection wrapper instead of a set. To restore efficient set operations, create a new set from the result.
let primesStrings = primes.map(String.init)
// 'primesStrings' is of type Array<String>
let primesStringsSet = Set(primes.map(String.init))
// 'primesStringsSet' is of type Set<String>Bridging Between Set and NSSet
You can bridge between Set and NSSet using the as operator. For bridging to be possible, the Element type of a set must be a class, an @objc protocol (a protocol imported from Objective-C or marked with the @objc attribute), or a type that bridges to a Foundation type.
Bridging from Set to NSSet always takes O(1) time and space. When the set’s Element type is neither a class nor an @objc protocol, any required bridging of elements occurs at the first access of each element, so the first operation that uses the contents of the set (for example, a membership test) can take O(n).
Bridging from NSSet to Set first calls the copy(with:) method (- copyWithZone: in Objective-C) on the set to get an immutable copy and then performs additional Swift bookkeeping work that takes O(1) time. For instances of NSSet that are already immutable, copy(with:) returns the same set in constant time; otherwise, the copying performance is unspecified. The instances of NSSet and Set share buffer using the same copy-on-write optimization that is used when two instances of Set share buffer.
Citizens in Swift
Members
init(minimumCapacity: Int) Creates an empty set with preallocated space for at least the specified number of elements.
Citizens in Swift
where Element:HashableConformances
protocol CollectionA sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.
protocol CustomDebugStringConvertibleA type with a customized textual representation suitable for debugging purposes.
protocol CustomReflectableA type that explicitly supplies its own mirror.
protocol CustomStringConvertibleA type with a customized textual representation.
protocol EquatableA type that can be compared for value equality.
protocol ExpressibleByArrayLiteralA type that can be initialized using an array literal.
protocol HashableA type that can be hashed into a
Hasherto produce an integer hash value.protocol SequenceA type that provides sequential, iterated access to its elements.
protocol SetAlgebraA type that provides mathematical set operations.
Members
init() Creates an empty set.
init<Source>(Source) Creates a new set from a finite sequence of items.
init(arrayLiteral: Element...) Creates a set containing the elements of the given array literal.
var capacity: IntThe total number of elements that the set can contain without allocating new storage.
var count: IntThe number of elements in the set.
var customMirror: MirrorA mirror that reflects the set.
var debugDescription: StringA string that represents the contents of the set, suitable for debugging.
var description: StringA string that represents the contents of the set.
var endIndex: Set<Element>.IndexThe “past the end” position for the set—that is, the position one greater than the last valid subscript argument.
var isEmpty: BoolA Boolean value that indicates whether the set is empty.
var startIndex: Set<Element>.IndexThe starting position for iterating members of the set.
subscript(Set<Element>.Index) -> Element Accesses the member at the given position.
static func == (Set<Element>, Set<Element>) -> Bool Returns a Boolean value indicating whether two sets have equal elements.
func contains(Element) -> Bool Returns a Boolean value that indicates whether the given element exists in the set.
func filter((Element) throws -> Bool) rethrows -> Set<Element> Returns a new set containing the elements of the set that satisfy the given predicate.
func firstIndex(of: Element) -> Set<Element>.Index? Returns the index of the given element in the set, or
nilif the element is not a member of the set.func formIndex(after: inout Set<Element>.Index) func formIntersection<S>(S) Removes the elements of the set that aren’t also in the given sequence.
func formSymmetricDifference(Set<Element>) Removes the elements of the set that are also in the given sequence and adds the members of the sequence that are not already in the set.
func formSymmetricDifference<S>(S) Replace this set with the elements contained in this set or the given set, but not both.
func formUnion<S>(S) Inserts the elements of the given sequence into the set.
func hash(into: inout Hasher) Hashes the essential components of this value by feeding them into the given hasher.
func index(after: Set<Element>.Index) -> Set<Element>.Index func insert(Element) -> (inserted: Bool, memberAfterInsert: Element) Inserts the given element in the set if it is not already present.
func intersection(Set<Element>) -> Set<Element> Returns a new set with the elements that are common to both this set and the given sequence.
func intersection<S>(S) -> Set<Element> Returns a new set with the elements that are common to both this set and the given sequence.
func isDisjoint(with: Set<Element>) -> Bool Returns a Boolean value that indicates whether this set has no members in common with the given set.
func isDisjoint<S>(with: S) -> Bool Returns a Boolean value that indicates whether the set has no members in common with the given sequence.
func isStrictSubset(of: Set<Element>) -> Bool Returns a Boolean value that indicates whether the set is a strict subset of the given sequence.
func isStrictSubset<S>(of: S) -> Bool Returns a Boolean value that indicates whether the set is a strict subset of the given sequence.
func isStrictSuperset(of: Set<Element>) -> Bool Returns a Boolean value that indicates whether the set is a strict superset of the given sequence.
func isStrictSuperset<S>(of: S) -> Bool Returns a Boolean value that indicates whether the set is a strict superset of the given sequence.
func isSubset(of: Set<Element>) -> Bool Returns a Boolean value that indicates whether this set is a subset of the given set.
func isSubset<S>(of: S) -> Bool Returns a Boolean value that indicates whether the set is a subset of the given sequence.
func isSuperset(of: Set<Element>) -> Bool Returns a Boolean value that indicates whether this set is a superset of the given set.
func isSuperset<S>(of: S) -> Bool Returns a Boolean value that indicates whether the set is a superset of the given sequence.
func makeIterator() -> Set<Element>.Iterator Returns an iterator over the members of the set.
func popFirst() -> Element? Removes and returns the first element of the set.
func remove(Element) -> Element? Removes the specified element from the set.
func remove(at: Set<Element>.Index) -> Element Removes the element at the given index of the set.
func removeAll(keepingCapacity: Bool) Removes all members from the set.
func removeFirst() -> Element Removes the first element of the set.
func reserveCapacity(Int) Reserves enough space to store the specified number of elements.
func subtract(Set<Element>) Removes the elements of the given set from this set.
func subtract<S>(S) Removes the elements of the given sequence from the set.
func subtracting(Set<Element>) -> Set<Element> Returns a new set containing the elements of this set that do not occur in the given set.
func subtracting<S>(S) -> Set<Element> Returns a new set containing the elements of this set that do not occur in the given sequence.
func symmetricDifference<S>(S) -> Set<Element> Returns a new set with the elements that are either in this set or in the given sequence, but not in both.
func union<S>(S) -> Set<Element> Returns a new set with the elements of both this set and the given sequence.
func update(with: Element) -> Element? Inserts the given element into the set unconditionally.
struct IndexThe position of an element in a set.
struct IteratorAn iterator over the members of a
Set<Element>.
Features
var first: Self.Element?The first element of the collection.
var lazy: LazySequence<Self>A sequence containing the same elements as this sequence, but on which some operations, such as
mapandfilter, are implemented lazily.static func != (Self, Self) -> Bool func allSatisfy((Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.
func compactMap<ElementOfResult>((Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] Returns an array containing the non-
nilresults of calling the given transformation with each element of this sequence.func contains(where: (Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
func drop(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence Returns a subsequence by skipping elements while
predicatereturnstrueand returning the remaining elements.func dropFirst(Int) -> Self.SubSequence Returns a subsequence containing all but the given number of initial elements.
func dropLast(Int) -> Self.SubSequence Returns a subsequence containing all but the specified number of final elements.
func elementsEqual<OtherSequence>(OtherSequence) -> Bool Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.
func elementsEqual<OtherSequence>(OtherSequence, by: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.
func enumerated() -> EnumeratedSequence<Self> Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero and x represents an element of the sequence.
func first(where: (Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the first element of the sequence that satisfies the given predicate.
func firstIndex(where: (Self.Element) throws -> Bool) rethrows -> Self.Index? Returns the first index in which an element of the collection satisfies the given predicate.
func flatMap<SegmentOfResult>((Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.
func forEach((Self.Element) throws -> Void) rethrows Calls the given closure on each element in the sequence in the same order as a
for-inloop.func formIndex(inout Self.Index, offsetBy: Int) Offsets the given index by the specified distance.
func formIndex(inout Self.Index, offsetBy: Int, limitedBy: Self.Index) -> Bool Offsets the given index by the specified distance, or so that it equals the given limiting index.
func joined() -> FlattenSequence<Self> Returns the elements of this sequence of sequences, concatenated.
func joined<Separator>(separator: Separator) -> JoinedSequence<Self> Returns the concatenated elements of this sequence of sequences, inserting the given separator between each element.
func joined(separator: String) -> String Returns a new string by concatenating the elements of the sequence, adding the given separator between each element.
func lexicographicallyPrecedes<OtherSequence>(OtherSequence) -> Bool Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the less-than operator (
<) to compare elements.func lexicographicallyPrecedes<OtherSequence>(OtherSequence, by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.
func map<T>((Self.Element) throws -> T) rethrows -> [T] Returns an array containing the results of mapping the given closure over the sequence’s elements.
func map<T>((Self.Element) throws -> T) rethrows -> [T] Returns an array containing the results of mapping the given closure over the sequence’s elements.
func max() -> Self.Element? Returns the maximum element in the sequence.
func max(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the maximum element in the sequence, using the given predicate as the comparison between elements.
func min() -> Self.Element? Returns the minimum element in the sequence.
func min(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the minimum element in the sequence, using the given predicate as the comparison between elements.
func prefix(Int) -> Self.SubSequence Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.
func prefix(through: Self.Index) -> Self.SubSequence Returns a subsequence from the start of the collection through the specified position.
func prefix(upTo: Self.Index) -> Self.SubSequence Returns a subsequence from the start of the collection up to, but not including, the specified position.
func prefix(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence Returns a subsequence containing the initial elements until
predicatereturnsfalseand skipping the remaining elements.func randomElement() -> Self.Element? Returns a random element of the collection.
func randomElement<T>(using: inout T) -> Self.Element? Returns a random element of the collection, using the given generator as a source for randomness.
func reduce<Result>(Result, (Result, Self.Element) throws -> Result) rethrows -> Result Returns the result of combining the elements of the sequence using the given closure.
func reduce<Result>(into: Result, (inout Result, Self.Element) throws -> ()) rethrows -> Result Returns the result of combining the elements of the sequence using the given closure.
func reversed() -> [Self.Element] Returns an array containing the elements of this sequence in reverse order.
func shuffled() -> [Self.Element] Returns the elements of the sequence, shuffled.
func shuffled<T>(using: inout T) -> [Self.Element] Returns the elements of the sequence, shuffled using the given generator as a source for randomness.
func sorted() -> [Self.Element] Returns the elements of the sequence, sorted.
func sorted(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element] Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.
func split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence] Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.
func split(separator: Self.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence] Returns the longest possible subsequences of the collection, in order, around elements equal to the given element.
func starts<PossiblePrefix>(with: PossiblePrefix) -> Bool Returns a Boolean value indicating whether the initial elements of the sequence are the same as the elements in another sequence.
func starts<PossiblePrefix>(with: PossiblePrefix, by: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.
func suffix(Int) -> Self.SubSequence Returns a subsequence, up to the given maximum length, containing the final elements of the collection.
func suffix(from: Self.Index) -> Self.SubSequence Returns a subsequence from the specified position to the end of the collection.
func flatMap<ElementOfResult>((Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func index(of: Self.Element) -> Self.Index? Returns the first index where the specified value appears in the collection.
Citizens in Swift
where Element:Decodable, Element:HashableConformances
protocol DecodableA type that can decode itself from an external representation.
Members
init(from: Decoder) throws Creates a new set by decoding from the given decoder.
Citizens in Swift
where Element:Hashable, Element:SendableConformances
protocol SendableA type whose values can safely be passed across concurrency domains by copying.
Citizens in Swift
where Element:Encodable, Element:HashableConformances
protocol EncodableA type that can encode itself to an external representation.
Members
func encode(to: Encoder) throws Encodes the elements of this set into the given encoder in an unkeyed container.
Citizens in Swift
where Element == AnyHashableMembers
Extension in BSON
where Element:Encodable, Element:HashableConformances
Members
Extension in Meow
where Element:Resolvable, Element:HashableConformances
protocol ResolvableA protocol that provides a uniform syntax for ‘resolving’ something
Extension in SwiftSyntaxBuilder
where Element:Hashable, Element:ExpressibleByLiteralSyntaxConformances
protocol ExpressibleByLiteralSyntaxA Swift type whose value can be represented directly in source code by a Swift literal.