Skip to main content

Swift Key Path Expressions

Introduction​

Swift key paths are a powerful feature that allow you to reference properties of types rather than specific instances. Introduced in Swift 4, key paths provide a type-safe way to refer to properties without actually accessing them immediately. This enables more flexible and reusable code patterns, especially when working with collections, functional programming techniques, and configuration-based systems.

Think of a key path as a recipe or a map that describes how to get to a specific property, rather than the value of the property itself. This concept might seem abstract at first, but as we explore examples, you'll see how key paths can lead to cleaner, more maintainable code.

Understanding Key Path Expressions​

Basic Syntax​

In Swift, key path expressions always start with a backslash (\), followed by a type name, a period, and then a property name:

swift
\Type.property

Let's see a simple example:

swift
struct Person {
    var name: String
    var age: Int
}

// This is a key path to the name property of Person
let nameKeyPath = \Person.name

The variable nameKeyPath doesn't contain a specific name value; instead, it describes how to access the name property of any Person instance.

Using Key Paths​

To actually use a key path, you apply it to an instance using the keyPath subscript:

swift
let person = Person(name: "Alice", age: 30)

// Access the name property using the key path
let name = person[keyPath: nameKeyPath]
print(name)  // Output: Alice

// You can also use key paths directly
let age = person[keyPath: \Person.age]
print(age)   // Output: 30

Modifying Values with Key Paths​

Key paths can also be used to modify values if the property is mutable and the instance is a variable:

swift
var mutablePerson = Person(name: "Bob", age: 25)

// Modifying a value using a key path
mutablePerson[keyPath: \Person.age] = 26

print(mutablePerson.age)  // Output: 26

Nested Properties​

Key paths can drill down into nested properties:

swift
struct Address {
    var street: String
    var city: String
}

struct Employee {
    var name: String
    var address: Address
}

let employee = Employee(
    name: "Charlie",
    address: Address(street: "123 Main St", city: "Swiftville")
)

// Access nested properties with key paths
let cityKeyPath = \Employee.address.city
let city = employee[keyPath: cityKeyPath]
print(city)  // Output: Swiftville

Key Path Types​

Swift provides several types for key paths:

  1. KeyPath<Root, Value>: Read-only access to a property of type Value from a Root type
  2. WritableKeyPath<Root, Value>: Read-write access to a property (for var properties)
  3. ReferenceWritableKeyPath<Root, Value>: For reference types, allows writing even if the root is a let constant
swift
// Read-only key path
let nameKeyPath: KeyPath<Person, String> = \Person.name

// Writable key path
let ageKeyPath: WritableKeyPath<Person, Int> = \Person.age

// Reference writable key path (for classes)
class User {
    var id: Int
    init(id: Int) { self.id = id }
}

let idKeyPath: ReferenceWritableKeyPath<User, Int> = \User.id

Practical Applications​

1. Sorting Collections​

Key paths make sorting collections by various properties very elegant:

swift
let people = [
    Person(name: "Dave", age: 20),
    Person(name: "Eve", age: 22),
    Person(name: "Frank", age: 18)
]

// Sort by age using a key path
let sortedByAge = people.sorted(by: { $0[keyPath: \Person.age] < $1[keyPath: \Person.age] })

// Swift provides a shorthand for this common pattern
let alsoSortedByAge = people.sorted(by: \.age)

print(sortedByAge.map { $0.name })  // Output: ["Frank", "Dave", "Eve"]

2. Mapping Properties from Collections​

Extract specific properties from a collection:

swift
// Extract all names from people array
let names = people.map(\.name)
print(names)  // Output: ["Dave", "Eve", "Frank"]

3. Key-Value Observing (KVO)​

Key paths integrate nicely with Swift's KVO system:

swift
class Temperature: NSObject {
    @objc dynamic var celsius: Double = 0
    var fahrenheit: Double {
        get { return celsius * 9/5 + 32 }
        set { celsius = (newValue - 32) * 5/9 }
    }
}

let thermometer = Temperature()

// Observe changes to celsius property using a key path
let observation = thermometer.observe(\.celsius, options: [.new, .old]) { object, change in
    print("Temperature changed from \(change.oldValue ?? 0)°C to \(change.newValue ?? 0)°C")
}

thermometer.celsius = 25  // Output: Temperature changed from 0.0°C to 25.0°C

4. Building Configuration Systems​

Key paths enable elegant property configuration:

swift
struct Configuration {
    var isDebugMode: Bool = false
    var serverURL: String = "https://api.example.com"
    var timeout: TimeInterval = 30
}

func configure<T>(_ object: inout Configuration, keyPath: WritableKeyPath<Configuration, T>, value: T) {
    object[keyPath: keyPath] = value
}

var config = Configuration()
configure(&config, keyPath: \.isDebugMode, value: true)
configure(&config, keyPath: \.timeout, value: 60)

print("Debug mode: \(config.isDebugMode), Timeout: \(config.timeout)")
// Output: Debug mode: true, Timeout: 60.0

5. Building Dynamic Forms​

Key paths can help build reusable form components:

swift
struct FormField<T> {
    let label: String
    let keyPath: WritableKeyPath<User, T>
    let value: T
}

class User {
    var name: String = ""
    var email: String = ""
    var age: Int = 0
}

let nameField = FormField(label: "Name", keyPath: \User.name, value: "")
let emailField = FormField(label: "Email", keyPath: \User.email, value: "")
let ageField = FormField(label: "Age", keyPath: \User.age, value: 0)

// This could be used to build a form and update a user object
func updateUser<T>(_ user: User, field: FormField<T>, newValue: T) {
    user[keyPath: field.keyPath] = newValue
}

let user = User()
updateUser(user, field: nameField, newValue: "John")
updateUser(user, field: emailField, newValue: "[email protected]")

print("User: \(user.name), \(user.email)")
// Output: User: John, [email protected]

Advanced Key Path Features​

Combining Key Paths​

Swift allows you to append key paths to navigate deeper into structures:

swift
struct Company {
    var name: String
    var ceo: Employee
}

let company = Company(
    name: "Swift Corp",
    ceo: Employee(name: "Tim", address: Address(street: "1 Infinite Loop", city: "Cupertino"))
)

// Create a key path to the CEO's city
let companyToEmployee = \Company.ceo
let employeeToCity = \Employee.address.city

// Append the key paths
let companyToCeoCity = companyToEmployee.appending(path: employeeToCity)

// Use the combined key path
let ceosCity = company[keyPath: companyToCeoCity]
print(ceosCity)  // Output: Cupertino

Key Paths with Collections and Optionals​

Key paths work seamlessly with collections and optional values:

swift
struct Team {
    var members: [Person]?
}

let team = Team(members: [
    Person(name: "Alice", age: 30),
    Person(name: "Bob", age: 25)
])

// Access the first team member's name (if it exists)
let firstMemberNameKeyPath = \Team.members?.first?.name
if let firstName = team[keyPath: firstMemberNameKeyPath] {
    print("First team member: \(firstName)")
}
// Output: First team member: Alice

Summary​

Swift key path expressions provide a powerful way to work with properties in a type-safe, reusable manner. They enable you to:

  • Reference properties without immediately accessing them
  • Create more abstract, reusable functions that work with different property types
  • Write cleaner, more concise code when working with collections
  • Build flexible systems for configuration and property management

As you become more comfortable with key paths, you'll find they enable new patterns and abstractions in your Swift code, particularly when combined with Swift's functional programming features.

Additional Resources​

Exercises​

  1. Create a filtering system that takes a collection of objects and a key path, and returns elements where the property at that key path meets some criteria.

  2. Implement a generic sorting function that can sort any collection by any property specified via a key path.

  3. Build a simple data binding system using key paths that keeps a UI element in sync with a property in a data model.

  4. Create a function that dynamically generates statistics (min, max, average) for any numeric property in a collection, specified by a key path.


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)