In this episode of the Swift introduction series we’ll be looking at enums in Swift.
Enumerations (aka enums) are found in most programming languages as a means to
associate a symbol with set membership over a closed group of alternatives. In
some cases, the values associated with an enum are meaningless (e.g.
Female) and in other cases they hold useful
East might have a value of 90 and
NorthEast might have a value of 45).
Traditional languages represented an enumeration always as an alias for an
integral value and used sleight-of-hand to replace the value at compile time,
like a set of
#define constants. Although this worked, it meant
that enums could be substituted for one another even when it didn’t make sense
Male == North).
Swift’s enums are more powerful, and enum types are distinct, even if they represent the same values. As a result, it is not possible to compare two enums for equality unless they are of the same type.
For example, to create a simple enum for representing gender:
1 2 3 4 5
There’s no comparison or ordering between different elements; they are just a property which can be one or the other. The enumeration type can be used as an argument type, return type, or variable type using a dot syntax as with structures:
1 2 3 4 5 6
Since Swift knows that the type of the variable is
Gender, it is not
necessary to supply the type of the enumeration at the point of use. This
has exactly the same effect:
1 2 3 4 5 6
This is commonly seen when passing in flags or other properties in a Swift
function. In particular, most of the existing constants in the Objective-C
codebase (such as
UIDeviceOrientation) are exposed as Swift enumerations,
meaning that just the value can be used (such as
Enumerations can also store values along with their types as well. For example, in nuclear physics, atoms are made up of Quarks, which can have an associated colour property of Red, Blue or Green. These can be represented as enumerations as follows:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
The values in an enum can also be used in patterns in a switch statement. For example, to represent a suit of cards it’s possible to represent both suits and face values:
1 2 3 4 5 6 7 8 9 10 11
In the same way that values like
Card.Face(.Ace,.Spades) can be used to
create a card, it can be used to match a card as well:
1 2 3 4 5 6 7 8 9 10
The use of enums as pattern matchable objects is very useful for fungible data structures, like structs. However enums aren’t expected to be fully fledged objects; rather, they are useful at representing orthogonal states for a particular system; whether it be a quark or a card.
In next week’s episode, we’ll look at how to do more functional programming in Swift. To subscribe to this series, add the Swift tag feed to your reader.