CustomValueOptionSet
Option set implementation which allows each option to have custom string value attached.




Provides a text value description for userprovided options.
The option set will recognize a custom option if it’s unique
rawValue
flag is set andcustomOptionsByRawValue
contains a description for that flag. Use theupdate(customOption:comparisonPolicy:)
method to append a custom option. 

contains(_:comparisonPolicy:)
Default implementationReturns 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!"
Default Implementation

union(_:comparisonPolicy:)
Default implementationReturns 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 theattendees
andvisitors
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]"
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.Default Implementation

formUnion(_:comparisonPolicy:)
Default implementationAdds the elements of the given set to the set.
In the following example, the elements of the
visitors
set are added to theattendees
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]"
Default Implementation

intersection(_:comparisonPolicy:)
Default implementationReturns 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 theemployees
andneighbors
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"]"
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.Default Implementation

formIntersection(_:comparisonPolicy:)
Default implementationRemoves 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 theneighbors
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"]"
Default Implementation

symmetricDifference(_:comparisonPolicy:)
Default implementationReturns 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 theemployees
andneighbors
sets that are not in bothemployees
andneighbors
. In particular, the names"Bethany"
and"Eric"
do not appear ineitherNeighborsOrEmployees
.let employees: Set = ["Alicia", "Bethany", "Diana", "Eric"] let neighbors: Set = ["Bethany", "Eric", "Forlani"] let eitherNeighborsOrEmployees = employees.symmetricDifference(neighbors) print(eitherNeighborsOrEmployees) // Prints "["Diana", "Forlani", "Alicia"]"
Default Implementation

formSymmetricDifference(_:comparisonPolicy:)
Default implementationRemoves 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 ofneighbors
are removed fromemployees
, while the elements ofneighbors
that are not members ofemployees
are added toemployees
. In particular, the names"Bethany"
and"Eric"
are removed fromemployees
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"]"
Default Implementation

subtracting(_:comparisonPolicy:)
Default implementationReturns 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 theemployees
set that are not elements ofneighbors
: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"]"
Default Implementation

subtract(_:comparisonPolicy:)
Default implementationRemoves the elements of the given set from this set.
In the following example, the elements of the
employees
set that are also members of theneighbors
set are removed. In particular, the names"Bethany"
and"Eric"
are removed fromemployees
.var employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"] employees.subtract(neighbors) print(employees) // Prints "["Diana", "Chris", "Alicia"]"
Default Implementation

insert(_:comparisonPolicy:)
Default implementationInserts 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 intoclassDays
, a set of days of the week. When an existing element is inserted, theclassDays
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]"
Default Implementation

remove(_:comparisonPolicy:)
Default implementationRemoves the given element and any elements subsumed by the given element.
For sets where the set type and element type are the same, like
OptionSet
types, this method returns any intersection between the set and[member]
, ornil
if the intersection is empty.Default Implementation

update(with:comparisonPolicy:)
Default implementationInserts 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 intoclassDays
, 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)"
For sets where the set type and element type are the same, like
OptionSet
types, this method returns any intersection between the set and[newMember]
, ornil
if the intersection is empty.Default Implementation

update(customOption:comparisonPolicy:)
Default implementationInserts the given element into the set unconditionally.
If an element equal to
customOption
is already contained in the set,customOption
replaces the existing element. Otherwise  updates the set contents and fillscustomOptionsByRawValue
accordingly.For sets where the set type and element type are the same, like
OptionSet
types, this method returns any intersection between the set and[customOption]
, ornil
if the intersection is empty.Default Implementation

isSubset(of:comparisonPolicy:)
Default implementationReturns 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"
Default Implementation

isSuperset(of:comparisonPolicy:)
Default implementationReturns 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"
Default Implementation

isStrictSubset(of:comparisonPolicy:)
Default implementationReturns a Boolean value that indicates whether this set is a strict subset of the given set.
Set A is a strict subset of another set B if every member of A is also a member of B and B contains at least one element that is not a member of A.
let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let attendees: Set = ["Alicia", "Bethany", "Diana"] print(attendees.isStrictSubset(of: employees)) // Prints "true" // A set is never a strict subset of itself: print(attendees.isStrictSubset(of: attendees)) // Prints "false"
Default Implementation

isStrictSuperset(of:comparisonPolicy:)
Default implementationReturns a Boolean value that indicates whether this set is a strict superset of the given set.
Set A is a strict superset of another set B if every member of B is also a member of A and A contains at least one element that is not a member of B.
let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let attendees: Set = ["Alicia", "Bethany", "Diana"] print(employees.isStrictSuperset(of: attendees)) // Prints "true" // A set is never a strict superset of itself: print(employees.isStrictSuperset(of: employees)) // Prints "false"
Default Implementation

isDisjoint(with:comparisonPolicy:)
Default implementationReturns 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 thevisitors
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"
Default Implementation

contains(_:)
Extension method 
union(_:)
Extension method 
intersection(_:)
Extension method 
symmetricDifference(_:)
Extension method 
insert(_:)
Extension method 
remove(_:)
Extension method 
update(with:)
Extension method 
formUnion(_:)
Extension method 
formIntersection(_:)
Extension method 
formSymmetricDifference(_:)
Extension method 
subtracting(_:)
Extension method 
isSubset(of:)
Extension method 
isDisjoint(with:)
Extension method 
isSuperset(of:)
Extension method 
subtract(_:)
Extension method