Chapters
Chapters

Chapters

Hide chapters

Swift Apprentice: Fundamentals

Second Edition · iOS 18 · Swift 6 · Xcode 16.2

Before You Begin

Section 0: 6 chapters
Show chapters Hide chapters

Section I: Swift Basics

Section 1: 6 chapters
Show chapters Hide chapters

Section II: Collection Types

Section 2: 4 chapters
Show chapters Hide chapters

Section III: Building Your Own Types

Section 3: 9 chapters
Show chapters Hide chapters

16. Enumerations
Written by Ehab Amer

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

One day in your life as a developer, you realize you’re being held captive by your laptop. Determined to break from convention, you set off on a long trek on foot. Of course, you need a map of the terrain you’ll encounter. Since it’s the 21st century and you’re fluent in Swift, you decide to create a custom map app.

As you code away, you think it would be swell to represent the cardinal directions as variables: north, south, east and west. But what’s the best way to do this in code?

You could represent each value as an integer, like so:

  • North: 1
  • South: 2
  • East: 3
  • West: 4

This encoding could quickly get confusing if you or your users happen to think of the directions in a different order. “What does 3 mean again?” To alleviate that, you might represent the values as strings, like so:

  • North: "north"
  • South: "south"
  • East: "east"
  • West: "west"

The trouble with strings, though, is that the value can be any string. What would your app do if it received "up" instead of "north"? Furthermore, it’s all too easy to make a typo like "nrth".

Wouldn’t it be great if there were a way to create a group of related, compiler-checked values? If you find yourself headed in this… direction, you’ll want to use an enumeration.

An enumeration is a list of related values that define a common type and let you work with values in a type-safe way. The compiler will catch your mistake if your code expects a Direction and you try to pass in a float like 10.7 or a misspelled direction like "Souuth".

Besides cardinal directions, other good examples of related values are colors (black, red, blue), card suits (hearts, spades, clubs, diamonds) and roles (administrator, editor, reader).

Enumerations in Swift are more powerful than they are in other languages, such as C or Objective-C. They share features with the structure and class types you learned about in Chapter 11, “Structures”, and Chapter 14, “Classes”. An enumeration can have methods and computed properties while holding a particular state.

In this chapter, you’ll learn how enumerations work and when they’re useful. As a bonus, you’ll finally discover what an optional is under the hood. Hint: They are implemented with enumerations!

Your First Enumeration

Your challenge: Construct a function to determine the school semester based on the month. One way to solve this would be to use an array of strings and match the semesters with a switch statement:

let months = ["January", "February", "March", "April", "May",
              "June", "July", "August", "September", "October",
              "November", "December"]

func semester(for month: String) -> String {
  switch month {
  case "August", "September", "October", "November", "December":
    return "Autumn"
  case "January", "February", "March", "April", "May":
    return "Spring"
  default:
    return "Not in the school year"
  }
}

semester(for: "April") // Spring

Running this code in a playground, you can see that the function correctly returns "Spring". But as you saw in the introduction, it’s easy to mistype a string. A better way to tackle this would be with an enumeration.

Declaring an Enumeration

To declare an enumeration, you list out all the possible member values as case clauses:

Deciphering an Enumeration in a Function

You can rewrite the function that determines the semester to use enumeration values instead of string matching.

Mini-Exercise

Wouldn’t it be nice to request the semester from an instance like month.semester instead of using the function? Add a semester computed property to the month enumeration so that you can run this code:

Using Code Completion to Prevent Typos

Another advantage of using enumerations instead of strings is that you’ll never have a typo in your member values. Xcode provides code completion:

Raw Values

Unlike enumeration values in C, Swift enum values are not backed by integers as a default. That means january is itself the value.

Accessing the Raw Value

Enumeration instances with raw values have a handy rawValue property. With the raw values in place, your enumeration has a sense of order, and you can calculate the number of months left until winter break:

Initializing With the Raw Value

You can use the raw value to instantiate an enumeration value with an initializer. You can use init(rawValue:) to do this, but if you try to use the value afterward, you’ll get an error:

Mini-Exercise

Make monthsUntilWinterBreak a computed property of the Month enumeration so that you can execute the following code:

String Raw Values

Similar to the handy trick of incrementing an Int raw value, if you specify a raw value type of String, you’ll get another automatic conversion. Pretend you’re building a news app that has tabs for each section. Each section has an icon. Icons are a good opportunity to deploy enumerations because, by their nature, they are a limited set:

Unordered Raw Values

Integer raw values don’t have to be in an incremental order. Coins are a good use case:

Mini-Exercise

Create an array called coinPurse that contains coins. Add an assortment of pennies, nickels, dimes and quarters to it.

Associated Values

Associated values take Swift enumerations to the next level in expressive power. They let you associate a custom value (or values) with each enumeration case.

Enumeration as a State Machine

An enumeration is an example of a state machine, meaning it can only ever be a single case at a time, never more. The friendly traffic light illustrates this concept well:

Mini-Exercise

A household light switch is another example of a state machine. Create an enumeration for a light that can switch .on and .off.

Iterating Through All Cases

Sometimes you want to loop through all of the cases in an enumeration. This is easy to do:

Enumerations Without Any Cases

In Chapter 13, “Methods,” you learned how to create a namespace for a group of related type methods. The example in that chapter looked like this:

Mini-Exercise

Euler’s number is useful in calculating statistical bell curves and compound growth rates. Add the constant e, 2.7183, to your Math namespace. Then you can figure out how much money you’ll have if you invest $25,000 at 7% continuous interest for 20 years:

Optionals

Since you’ve made it this far, the time has come to let you in on a little secret. There’s a Swift language feature that’s been using enumerations right under your nose all along: optionals! In this section, you’ll explore their underlying mechanism.

Challenges

Before moving on, here are some challenges to test your knowledge of enumerations. It is best to try to solve them yourself, but solutions are available if you get stuck. These came with the download or are available at the printed book’s source code link listed in the introduction.

Challenge 1: Adding Raw Values

Take the coin example from earlier in the chapter and begin with the following array of coins:

Challenge 2: Computing With Raw Values

Take the example from earlier in the chapter and begin with the Month enumeration:

Challenge 3: Pattern Matching Enumeration Values

Take the map example from earlier in the chapter and begin with the Direction enumeration:

Key Points

  • An enumeration is a list of mutually exclusive cases that define a common type.
  • Enumerations provide a type-safe alternative to old-fashioned integer values or strings.
  • You can use enumerations to handle responses, store state and encapsulate values.
  • CaseIterable lets you loop through an enumeration with allCases.
  • Uninhabited enumerations can be used as namespaces and prevent the creation of instances.
  • The Swift Optional type is a generic enumeration with cases .none and .some.
15. Advanced Classes
17. Protocols
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now