In Swift there are three primary collection types – arrays, dictionaries and sets. We’ve already covered arrays and dictionaries in previous posts and in this post we’re going to complete the set (no pun intended) by looking at sets.
Table of Contents
What is a Set?
In Swift, sets are unordered collections of unique values. This means that like a dictionary, the values held in a Swift set aren’t held in any particular order and like the keys in a dictionary, there can’t be any duplicate values.
Like the other collection types in Swift, sets in Swift are also strongly typed. This means that only values of one specified type can be held within a set and although this may seem restrictive, as we’ve seen in previous articles, this actually helps us to avoid bugs by ensuring that we don’t insert values of the incorrect type.
Hash Values for Set Types
On top of only being able to hold a single type, the Swift language, also imposes one more requirement on the types of values that can be held in a set – the types of values that can be held must conform to Swift’s hashable protocol.
This may sound all fancy but all this really means is that values of the specified type must have an Int property called hashValue that can be used as a representation of the value.
In addition, because the Hashable protocol in Swift itself conforms to the Equatable protocol, it means that the type must also supply an implementation of the equality operator (==) as well. The Swift language then uses the hashValue and the equality operator to compare different values within the set (via their hashValue) to ensure that they are unique.
So you may be wondering which types of values conform to this Hashable protocol. The good news here is that pretty much all of the basic types in Swift are hashable by default. This includes the String, Int, Double and Bool types as well as any enumeration types that don’t have associated values.
Ok, so that’s what a set is (a strongly typed, unordered collection of unique values) but what about actually creating one? Before we look at how to do this, let’s first look at how the mutability of sets is controlled.
Declaring and Initialising a Set
Mutable versus Immutable Sets
As with other collection types in Swift, the mutability of a set is governed by whether we declare that set using the var or let keywords.
As we’ve seen with other collections, if declared with the var keyword, the contents of the set will be mutable – meaning that it can be mutated or changed by adding, removing or changing items within the set.
If the set is declared with the let keyword however the set is said to be immutable or unchangeable. This means that both the sets size and its contents cannot be changed.
Creating an Empty Set
In Swift, there are a number of ways that you can create a set. The first of these is using initialiser syntax.
Initialisation syntax makes use of an initialisation function:
var firstSet = Set<String>()Let’s walk through this slowly to start with.
Here I’ve started off our declaration as we would when defining any variable – using the var keyword. As we’ve just seen, this means that the set I’m creating here is going to be mutable (i.e. we’re going to be able to modify it). We then have the name of the variable into which we’re going to store the set.
In this example I’m also taking advantage of Swift’s type inference mechanism as well. This allows me to infer the type of our firstSet variable, without having to explicitly state it. We’ll come to exactly what type this set is in a moment.
After declaring our mutable set variable we then have the assignment operator and then the Set type name. The Set type (in similar fashion to the Array type we saw in previous posts) is a generic type in Swift. This means that when we declare a set using initialiser syntax we not only supply the Set type but also have to supply an additional type between angled brackets (< >) to define the type of values that the set will hold. In this case I’ve declared the set to hold values of type String so the full type for the set is Set<String> and Swift infers it as such.
The final piece to the puzzle comes after the sets type. These are a set of parentheses that represent the call to the initialisation function which creates the set. The Set type in Swift has a number of these initialisation functions, some with parameters and one without, and it is this form, the one without an argument, that creates an empty set of the specified type.
Creating an Empty Set with an Array Literal
So that’s how to create an empty set using initialisation syntax but we actually have a couple of other ways of creating empty sets in Swift as well, both of which use array literals.
As I mentioned, the Set type in Swift has a number of initialisation functions and one of these functions takes an array literal as a parameter. This particular initialisation function then uses that array parameter to populate the contents of the set it creates.
Our first alternative for creating an empty set then, is to make use of this initialisation function and provide it with an empty array literal:
let secondSet = Set<Double>([])The syntax is almost exactly the same as we’ve just seen and the result is essentially the same. This time I’ve declared secondSet using the let keyword resulting in an immutable set (one where we won’t be able to change the contents of the set) and have declared the set to hold values of type Double instead of String.
I’ve also supplied the empty array literal ([]) as a parameter to the initialisation function. The effect is that it uses this empty array literal to create an empty set of type Set<Double>.
Our final way of creating an an empty set in Swift is similar to this last one, but instead uses assignment.
In Swift, we can actually split the declaration of our set from it’s initialisation and as long as the sets type can be inferred from the context (which in the following example it can because of the explicit type declaration), we can assign an empty array literal to perform initialisation.
The result is exactly the same as our previous example:
let thirdSet : Set<Double>
thirdSet = []Now, empty sets are all very well but they’re not that interesting. What about creating a set that actually contains something useful?
Creating Sets That Actually Contain Some Values
In Swift, there are a couple of ways to declare and initialise a set that contains some values and the first technique is a simple extension to what we’ve already seen.
Creating a Set with an Array Literal
We’ve already seen how an empty set can be created by supplying an empty array literal as an initialisation parameter, but (as you can probably guess) we can also create a set that contains an initial set of values by using an array literal that itself contains some values.
Both the initialisation syntax (calling an initialisation function on the Set type) or the assignment approach we just looked at both work:
let fourthSet = Set<Int>([10, 30]) // Intialisation Syntax
let fifthSet : Set<Double>
fifthSet = [10.1, 37.2, 33.5] // AssignmentIn this example, we create two new immutable Sets. The first, (fourthSet) contains values of type Int and is inferred to be of type Set<Int>. The second, (fifthSet) is declared to store values of type Double and is inferred to be of type Set<Double>. In both cases, we also initialise the sets with values of the relevant types.
Now, you might think we’re done on the initialisation front, but there is one more, lesser known, initialisation option that I wanted to look at before we move on and that is initialising a set using a sequence.
Creating a Set with a Sequence
We’ve already touched on sequences in previous posts and took a cursory look at them when we talked about the open and closed range operators. The final initialisation function at our disposal makes use of sequences as it takes a sequence as a parameter and then uses the sequence to populate the elements within the set (one element in the set for each element in the sequence):
let sixthSet = Set<Int>(1...5)The result of the example above is an immutable set that stores values of type Int and contains the values 1, 2, 3, 4 and 5.
So we now know how to creating both an empty set and a set that actually contains some values. But what about working how many elements are already in a set? Let’s look at that next.
Checking if a Set is Empty
There are two ways in Swift that we can use to check how many elements are in set, both of which are accessible as properties of a given set.
This first of these properties is the isEmpty property. As the name suggests, it can be used to test whether the set is empty and returns a Bool value to indicate whether the set is empty or not:
firstSet.isEmpty
// trueCounting the Number of Elements in a Set
In addition to being able to test whether a set is empty or not, we can also determine the exact number of elements that are in a set.
Again, this is done via a property of the Set type. This time the property is called count and returns an Int value representing the number of elements contained in the set:
firstSet.count
// 0
fifthSet.count
// 3Adding an Element to a Set
Now that we know how to create a set that contains some values and count the number of elements in a set, the next thing to look at is how to add new elements to a set. For sets, this is done using the insert(_:) function.
The insert(_:) function accepts a single parameter of the same type as the elements stored within the set. (You’ll get an error if you try to supply a value of an incompatible type).
Let’s have look at an example.
Note: For this example and later ones I’ll use in this post I’m going to revisit an example I’ve used in a previous post, one using the characters from the latest Star Wars films.
Initially we’re going to create an empty forceAwakens set to hold some of the characters from the movie The Force Awakens, and we’re initially going to add a single element to it:
var forceAwakens = Set<String>()
forceAwakens.count // 0
forceAwakens.isEmpty // true
forceAwakens.insert("Rey") // 'forceAwakens' now contains one item "Rey"
forceAwakens.count // 1In this example, we declare a new set called forceAwakens. We’ll use this to hold the names of the characters in the film.
Initially, the set is empty (and therefore has a count of 0) but we then use the insert(_:) function to insert the first of our characters (Rey). The result is that the set contains one element and the count reflects this.
To add multiple elements to a set, all we do is use the insert(_:) function multiple times within a loop:
for character in ["Finn", "BB-8", "Yoda", "C-3PO", "Han Solo", "Princes Leia"] {
forceAwakens.insert(character)
}
// {"Rey", "Han Solo", "Princess Leia", "BB-8", "Yoda", "C-3PO", "Chewbacca", "Finn"}
// Note: The elements in your set may be in a different order.As we’ll see later, there is also another way to add elements to a set using set operations (the unionInPlace(_:) function to be precise). Before we look at this though, we’ve got a couple of other things to look at. The first of these is how to access elements within a set.
Finding Elements in a Set
Let’s start this section off gently. We’ve now created our forceAwakens set, and have learnt how to create it with some initial characters and also how to add additional characters to it, but what about checking on whether a value is already in the set?
Finding If an Element is in a Set
To find out whether an item is already in a set or not, we can use the contains(_:) function.
The contains(_:) function takes a single element of the same type as the elements held within the set and returns a boolean value to indicate whether the element is present or not:
forceAwakens.contains("Yoda")
// trueBut we can go beyond simply checking whether an element is already in a set or not. We can also get the index of that element.
Finding the Index of an Element in a Set
As I mentioned at the start of this article, the elements in a set are not held in a defined order, but once inserted, elements in the set are located at particular indexes. As with other collections, the indexes of elements in a set start at 0 and then increment up to one less than the number of elements in the set.
For example, what if we wanted to get hold of the index of Yoda within the set. We could write:
forceAwakens.indexOf("Yoda")Note: If you run this yourself, you will likely get a different answer due to the unordered nature of the Set type.
The indexOf(_:) function returns a value of type SetIndex<T> where T is the type of value held in the set. We’ll see this again later in this article.
Iterating Over a Set
In addition to being able to identify the index of an element in a set we can also iterate over the sets elements.
We’ve seen this in previous articles with some of the other Swift collection types. The only thing to watch out for here is that the elements in the set are not held in any particular order so there is no guarantee about the order in which they will appear:
for character in forceAwakens {
print(character)
}
// Rey, Han Solo, Princess Leia, BB-8, Yoda, C-3PO, Chewbacca, FinnNote: If you do want the elements in a set in a given order, you can also use the sort() function to sort the values in the set before iterating over the array that results:
for character in forceAwakens.sort() {
print(character)
}
// BB-8, C-3PO, Chewbacca, Finn, Han Solo, Princess Leia, Rey, YodaNow that we know how to access elements in a set, there’s one final mechanism that I wanted to look at. I’ve left this one until last because not only does it access the element in the set, but it also modifies the set itself. This is the popFirst() function.
Removing Elements from a Set
Removing the First Element in a Set
If you’ve done any sort of programming before, you might be used to the idea of pushing things onto a stack and popping them off. I always think of it as a pile of plates. You push a plate onto the top of the stack and pop it back off.
The popFirst() function embodies this idea and is used to pop, the (notionally) first element of the set, returning the element and removing it from the set in the process:
// forceAwakens contains: {"Rey", "Han Solo", "Princess Leia", "BB-8", "Yoda", "C-3PO", "Chewbacca", "Finn"}
let firstVal = forceAwakens.popFirst()
print(firstVal)
// Rey
// forceAwakens now contains: {"Han Solo", "Princess Leia", "BB-8", "Yoda", "C-3PO", "Chewbacca", "Finn"}The popFirst() function actually returns an optional type. This accounts for the fact that in a situation where the set is empty, there is no value to return. In this situation, the popFirst() returns nil.
Now, we’re not done with removing the first element from a set. In addition to the popFirst() function, the Set type also has a removeFirst() function.
The removeFirst() function, has exactly the same behaviour as the the popFirst() function – it returns the (notionally) first element in the set and in doing so, removes that element from the set itself. However, unlike the popFirst() function, the removeFirst() function can only be used with a set that contains at least one element. If the set is empty and the removeFirst() function is called, an error will be thrown. It’s therefore prudent to first check that the set has at least one element before calling the removeFirst() function:
// forceAwakens contains: {"Han Solo", "Princess Leia", "BB-8", "Yoda", "C-3PO", "Chewbacca", "Finn"}
if forceAwakens.count > 0 {
let nextVal = forceAwakens.removeFirst()
print(nextVal)
}
// Han Solo
// forceAwakens now contains: {"Princess Leia", "BB-8", "Yoda", "C-3PO", "Chewbacca", "Finn"}So between the popFirst() and removeFirst() functions, we now know how to remove the first element from a set. But what if the element we wanted to remove wasn’t the first element? This is where the remove(_:) and removeAtIndex(_:) functions come in. Let’s look at the remove(_:) function first.
Removing an Element from a Set
The remove(_:) function allows us to remove a single element from the set on which the function is called. The function takes a single parameter of the same type as the elements stored within the set which is used to indicate the element you wish to removed. For example, say we wanted to remove Yoda from our forceAwakens set we could write:
// forceAwakens contains: {"Princess Leia", "BB-8", "Yoda", "C-3PO", "Chewbacca", "Finn"}
let item = forceAwakens.remove("Yoda")
print(item)
// Yoda
// forceAwakens now contains: {"Princess Leia", "BB-8", "C-3PO", "Chewbacca", "Finn"}As with the popFirst() and removeFirst() functions, the remove(_:) function returns the element that was removed from the set or nil if the element was not present (the return type of the remove(_:) function is an optional to account for this).
Removing An Element from a Set By Index
In addition to being able to remove an element directly, we can also remove an element from a set using the index of that element.
We saw how to get the index of an element earlier using the indexOf(_:) function. That returns an optional value representing the index of the specified element. Once we have the index, we can then supply that index to the removeAtIndex(_:) method which will both return the element at the given index and remove it from the set.
The thing to remember with the removeAtIndex(_:) function is that because the element must already be in the set (in order to have a valid index), the function returns a non-optional (rather than optional) value of the same type as those stored within the set:
// forceAwakens contains: {"Princess Leia", "BB-8", "C-3PO", "Chewbacca", "Finn"}
if let idx = forceAwakens.indexOf("BB-8") {
var otherItem = forceAwakens.removeAtIndex(idx)
print(otherItem)
}
// BB-8
// forceAwakens now contains: {"Princess Leia", "C-3PO", "Chewbacca", "Finn"}Removing Multiple Items from a Set
By now, we know how to retrieve elements from a set, and also how to remove individual elements (whether they be the nominally first element of the set or elsewhere). But what if we wanted to remove multiple items from a set?
There are a number of ways to approach this, two of which we’ll touch on now, and a couple that we’ll look at later in the article when we look at set operations. For now, let’s start with the simplistic approaches.
Given what we’ve learnt just now, the easiest way to remove multiple items from a set is to call one of the functions we just looked at multiple times. For example, we could call the remove(_:) function multiple times to remove a number of elements form the set:
// forceAwakens contains: {"Princess Leia", "C-3PO", "Chewbacca", "Finn"}
for character in ["Finn", "C-3PO"] {
let character = forceAwakens.remove(character)
print(character)
}
// Finn
// C-3PO
// forceAwakens now contains: {"Princess Leia", "Chewbacca"}There is however an alternative if we want to remove all elements from a set. Built into the Set type, is the removeAll(keepCapacity:) function which as you might expect, removes all the elements from a set. Note: The function has a default parameter for the keepCapacity parameter which most of the time you can ignore unless you explicitly want to keep the capacity of the set for performance reasons:
forceAwakens.removeAll()
// forceAwakens now contains: []Ok, so far we’ve covered the basics of Swift sets and if you stop reading here, you’d be wondering why you would want to use them. After all, they sound pretty similar to arrays (except for the non-ordered bit) and they don’t seem to be giving you much more benefit – so why us them?
The reality is that sets in Swift are actually extremely powerful but their real power comes from their ability to perform set operations and check for set membership and set equality. It’s these aspect that I want to touch on next. Let’s start by looking at the concepts of set membership and set equality.
Set Membership and Equality
You might remember some set theory from school but before we dive in, let’s have a bit of a refresher. In the diagram below, we have three sets – A, B and C. These are going to represent three sets of Star Wars characters:
The first set, set A, is going to be our set of characters from the film The Return of the Jedi. This set is declared to contain the following characters:
var returnOfTheJedi = Set<String>(["Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"])The next set, set B, is our set of characters from the newly released movie The Force Awakens. This set is declared as follows:
var forceAwakens2 = Set<String>(["Finn", "BB-8", "Yoda", "Chewbacca", "C-3PO", "R2-D2"])The characters in this set have some overlap with the characters in The Return of the Jedi, namely characters like Yoda, Chewbacca, C-3PO and R2-D2.
The overlap of sets A and B represent the characters that are in both set A (The Return of the Jedi) and set B (The Force Awakens). These include Yoda, Chewbacca, C-3PO and R2-D2.
Our final set is set C. Set C contains a single element and represents the robots from the film The Force Awakens (BB-8). Set C is declared as follows:
var robots = Set<String>(["BB-8"])Set C is said to be a subset of set B because all of the elements in Set B are are contained within Set C.
By inference, set B is also said to be a superset of set C because it contains all the elements of set C.
Ok, that lays out the various sets we’re going to use in the following examples. Let’s start off easy by examining the set statements I made above, but this time using Swift code.
Let’s start off by looking at how to determine whether the elements in two sets are equal.
Set Equality
Testing whether two sets are equal is actually really easy in Swift. All we have to do is to use the ‘is equal’ operator (==) just as you would with any boolean comparison.
For example, let’s first declare another set that contains identical elements to the robots set we saw just now:
var robots2 = Set<String>(["BB-8"])In the case of sets, the ‘is equal’ operator will only return true if the two sets contain exactly the same elements. If either set contains additional elements, the ‘is equal’ operator will return false:
robots2 == robots
// true
robots == forceAwakens2
// falseNote that in this second case, despite the fact that all of the elements in the robots set are contained within the forceAwakens2 set, the comparison returns false because the sets do not contain exactly the same elements.
Subset
The next thing we may want to test for is whether one set is a subset of another set. As we saw from our diagram, the robots from the Force Awakens (set C) is a subset of the characters in the film the Force Awakens (set B).
We can actually test for this in Swift using the isSubsetOf(_:) function. The function takes another set (or sequence) as it’s single parameter and returns a boolean value indicating whether all the elements of the first set are contained within the set supplied as a parameter:
robots.isSubsetOf(forceAwakens2)
// true
robots2.isSubsetOf(robots)
// trueNotice that in the case of the second set, the function also returns a value of true. This is due to the fact that these sets contain identical elements and the test (whether all elements of the first set are contained within the second set) actually returns true.
Strict Subset
Now, in addition to the isSubsetOf(_:) function, sets in Swift also have an additional function, the isStrictSubsetOf(_:) function. This function behaves in exactly the same way as the isSubsetOf(_:) function but returns false if the two sets are equal. For example:
robots.isStrictSubsetOf(forceAwakens2)
// true
robots2.isStrictSubsetOf(robots)
// falseNotice this time that the comparison of the robots2 set to the robots set, returns false. This is because the sets are equal actually equal.
Ok, that’s subsets, but let’s flip this around and look at it from the other perspective, whether one set is a superset of another or not.
Superset
As you might have guessed, sets in Swift also have a function called isSupersetOf(_:). This function allows us to test whether one is a superset of another. Again this function returns a boolean value:
forceAwakens2.isSupersetOf(robots)
// trueAnd in similar fashion to the isSubset(_:) function we just looked at, the isSupersetOf(_:) function also returns true for two sets if they have equal elements (as all the elements of the second set are contained within the first):
robots2.isSupersetOf(robots)
// trueStrict Superset
Finally, we also have the isStrictSupersetOf(_:) function. As you might expect, this behaves in the same manner as the isSupersetOf(_:) function but returns false if the two sets are identical:
forceAwakens2.isStrictSupersetOf(robots)
// true
robots2.isStrictSupersetOf(robots)
// falseThat about wraps up the set membership functions for Swift sets, but there is one final function that we need to look at before we move on. That is the isDisjointWith(_:) function.
Disjoint
So far we’ve looked at whether one set is a superset or subset of another set, but the isDisjointWith(_:) function allows us to test whether there is no overlap between two sets (or in fact, no overlap between a given set and any other value that compiles with Swift’s sequenceType protocol such as another set or an array).
For example, in our three Star Wars sets, there is no overlap between the characters in the Return of the Jedi movie (set A) and the robots in the movie the Force Awakens (set C). We can test for this as follows:
returnOfTheJedi.isDisjointWith(robots)
// trueBut there is an overlap between the forceAwakens2 set and the robots set and the isDisjoint(_:) function therefore returns false as the two sets overlap:
forceAwakens2.isDisjointWith(robots)
// falseSet Functions
Ok, so we’ve covered the basics of sets and can now test whether sets are either supersets or subsets of each other and whether there is no overlap between the two sets. If we follow this course of thinking, the next logical thing to look at is how to test whether there is a partial overlap between two sets. Let’s do that next.
Intersect / Intersect In Place
If we go back to the diagram of our three Star Wars sets, we can see that there is a partial overlap between the returnOfTheJedi set and the forceAwakens2 set:
In isolation, the set can be visualised as follows:
The Set type in Swift, has two functions that allow us to test for this overlap. The first is the intersect(_:) function.
The intersect(_:) function takes a single parameter. The parameter is anything that compiles with Swift’s SequenceType protocol and generates elements of the same type as those stored within the Set. In reality this usually means another Set or Array but it’s obviously not restricted to these types.
When called, the intersect(_:) function returns a Set containing those elements that are members of both the set on which the function is called and the set that is supplied as a parameter. For example:
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
// forceAwakens2 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
let commonCharacters = returnOfTheJedi.intersect(forceAwakens2)
// commonCharacters contains {"Yoda", "Chewbacca", "C-3PO", "R2-D2"}But as I mentioned, we don’t have to supply another set as a parameter, we could supply an array:
// forceAwakens2 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
let intersetSet = forceAwakens2.interset(["Yoda", "C-3PO", "Han Solo"])
// intersectSet contains {"R2-D2", "Yoda"}You get the idea.
Now, although the interset(_:) function returns a new set as a result we can also modify the original set, by using the intersectInPlace(_:) function.
Where the interset(_:) function returns a new set, the intersectInPlace(_:) function modifies the set upon which the intersect(_:) function is called. The result is that we can only call this function on mutable sets (i.e. those declared with the var keyword).
Note: So that we don’t change our original set, I’ll make a copy of the forceAwakens2 set for use in this example:
var forceAwakens3 = forceAwakens2
// forceAwakens3 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
forceAwakens3.intersectInPlace(returnOfTheJedi)
// forceAwakens3 now contains {"Yoda", "Chewbacca", "C-3PO", "R2-D2"}As you can see, the contents of the forceAwakens3 set is modified to only contain the values that are common between the two sets.
Union / Union in Place
The next pair of functions available on the Set type in Swift are the union(_:) and unionInPlace(_:) functions. Diagrammatically, they can be represented as follows:
The union(_:) function, returns a new function containing the elements from both the set on which the function is called and the functions parameter (again, any type that compiles with Swift’s sequenceType protocol):
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
// forceAwakens2 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
let combinedSet = forceAwakens2.union(returnOfTheJedi)
// combinedSet contains {"R2-D2", "BB-8", "Yoda", "Chewbacca", "C-3PO", "Darth Vader", "Finn"}In similar fashion to the interset(_:) function, the union(_:) also has a counterpart, the unionInPlace(_:) function, which does the same thing, but instead of returning a new set, modifies the set on which the function is called:
var forceAwakens4 = forceAwakens2
// forceAwakens4 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
forceAwakens4.unionInPlace(returnOfTheJedi)
// forceAwakens4 contains {"R2-D2", "BB-8", "Yoda", "Chewbacca", "C-3PO", "Darth Vader", "Finn"}Now, remember way back at the start of this article when we were looking at how to add elements to an existing set? You might have guessed that We can use the unionInPlace(_:) function to add multiple new elements to a set without having to all the insert(_:) function multiple times:
forceAwakens4.unionInPlace(["Kylo Ren", "Poe Dameron"])
// forceAwakens4 contains {"R2-D2", "Poe Dameron", "Kylo Ren", "BB-8", "Yoda", "Chewbacca", "C-3PO", "Darth Vader", "Finn"}Handy!
Exclusive OR / Exclusive OR in Place
Next up are the exclusiveOr(_:) and exclusiveOrInPlace(_:) functions. These functions identify those elements that are in either the set upon which the function is called, or the set / sequence supplied as a parameter but are not present in both. This can be visualised as follows:
In terms of our Star Wars sets, this essentially means identifying those characters that are either in the forceAwakens2 set or the returnOfTheJedi set but do not appear in both films:
// forceAwakens2 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
let uniqueCharacters = forceAwakens2.exclusiveOr(returnOfTheJedi)
// uniqueCharacters = {"Finn", "Darth Vader", "BB-8"}In similar fashion, we also have the exclusiveOrInPlace(_:) function that does the same thing but modifies the original set:
var forceAwakens5 = forceAwakens2
// forceAwakens5 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
forceAwakens5.exclusiveOrInPlace(returnOfTheJedi)
// forceAwakens5 contains {"Finn", "Darth Vader", "BB-8"}Subtract / Subtract In Place
Ok, we’re nearly there. Time for our last pair of functions, these are the subtract(_:) and subtractInPlace(_:) functions. These functions allow us to subtract the elements of one set or sequence from the elements of another. This can be illustrated as follows:
First, we have the subtract(_:) function. As with all the other set functions we’ve looked at, it takes a single parameter of any type that complies with Swift’s sequenceType protocol and removes the elements of that sequence from the set upon which the function is called:
// forceAwakens2 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
let uniqueToForceAwakens = forceAwakens2.subtract(returnOfTheJedi)
// uniqueToForceAwakens contains {"Finn", "BB-8"}Finally, we have the subtractInPlace(_:) function. You can probably guess what this does by now:
var forceAwakens6 = forceAwakens2
// forceAwakens6 contains {"Finn", "R2-D2", "Yoda", "Chewbacca", "C-3PO", "BB-8"}
// returnOfTheJedi contains {"Chewbacca", "C-3PO", "R2-D2", "Yoda", "Darth Vader"}
forceAwakens6.subtractInPlace(returnOfTheJedi)
// forceAwakens6 contains {"Finn", "BB-8"}Ok, I think we’ve done Swift’s Set type to death by now so we’ll wrap thing up there.
As ever, if you do have any questions (or if I’ve got anything wrong) please get in touch and if you do find this useful, I’d really appreciate it if you share it with your friends.