swift-case-paths

by pointfreeco

pointfreeco / swift-case-paths

🧰 Case paths bring the power and ergonomics of key paths to enums!

276 Stars 24 Forks Last release: 3 months ago (0.1.2) MIT License 16 Commits 3 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

🧰 CasePaths

Swift 5.3 Swift 5.2 CI @pointfreeco

Case paths bring the power and ergonomics of key paths to enums!

Motivation

Swift endows every struct and class property with a key path.

struct User {
  var id: Int
  var name: String
}

\User.id // WritableKeyPath \User.name // WritableKeyPath

This is compiler-generated code that can be used to abstractly zoom in on part of a structure, inspect and even change it, while propagating these changes to the structure's whole. They unlock the ability to do many things, like key-value observing and reactive bindings, dynamic member lookup, and scoping changes to the SwiftUI environment.

Unfortunately, no such structure exists for enum cases!

enum Authentication {
  case authenticated(accessToken: String)
  case unauthenticated
}

\Authentication.authenticated // 🛑

And so it's impossible to write similar generic algorithms that can zoom in on a particular enum case.

Introducing: case paths

This library intends to bridge this gap by introducing what we call "case paths." Case paths can be constructed simply by prepending the enum type and case name with a forward slash:

import CasePaths

/Authentication.authenticated // CasePath

Case paths vs. key paths

While key paths package up the functionality of getting and setting a value on a root structure, case paths package up the functionality of extracting and embedding a value on a root enumeration.

user[keyPath: \User.id] = 42
user[keyPath: \User.id] // 42

let authentication = (/Authentication.authenticated).embed("cafebeef") (/Authentication.authenticated).extract(from: authentication) // Optional("cafebeef")

Case path extraction can fail and return

nil
because the cases may not match up.
(/Authentication.authenticated).extract(from: .unauthenticated) // nil

Case paths, like key paths, compose. Where key paths use dot-syntax to dive deeper into a structure, case paths use a double-dot syntax:

\HighScore.user.name
// WritableKeyPath

/Result..Authentication.authenticated // CasePath, String>

Case paths, also like key paths, provide an "identity" path, which is useful for interacting with APIs that use key paths and case paths but you want to work with entire structure.

\User.self           // WritableKeyPath
/Authentication.self // CasePath

Key paths are created for every property, even computed ones, so what is the equivalent for case paths? Well, "computed" case paths can be created by providing custom

embed
and
extract
functions:
CasePath(
  embed: { decryptedToken in
    Authentication.authenticated(token: encrypt(decryptedToken))
  },
  extract: { authentication in
    guard
      case let .authenticated(encryptedToken) = authentication,
      let decryptedToken = decrypt(token)
      else { return nil }
    return decryptedToken
  }
)

Since Swift 5.2, key path expressions can be passed directly to methods like

map
. The same is true of case path expressions, which can be passed to methods like
compactMap
:
users.map(\User.name)
authentications.compactMap(/Authentication.authenticated)

Ergonomic associated value access

CasePaths uses Swift reflection to automatically and extract associated values from any enum in a single, short expression. This helpful utility is made available as a public module function that can be used in your own libraries and apps:

extract(case: Authentication.authenticated, from: .authenticated("cafebeef"))
// Optional("cafebeef")

Case paths without operators

The operators included with CasePaths make working with case paths feel a lot like working with key paths, but if your team or code base is operator-averse, they are not required.

// With operators:
/Authentication.authenticated
// Without:
CasePath.case(Authentication.authenticated)

// With operators: authentications.compactMap(/Authentication.authenticated) // Without: authentications.compactMap(extract(Authentication.authenticated))

// With operators: /Result.success..Authentication.authenticated // Without: CasePath.case(Result.success) .appending(path: .case(Authentication.authenticated))

// With operators: /Authentication.self // Without operators: CasePath.self

Installation

You can add CasePaths to an Xcode project by adding it as a package dependency.

https://github.com/pointfreeco/swift-case-paths

If you want to use CasePaths in a SwiftPM project, it's as simple as adding a

dependencies
clause to your
Package.swift
:
dependencies: [
  .package(url: "https://github.com/pointfreeco/swift-case-paths.git", from: "0.1.2")
]

Documentation

The latest documentation for CasePaths' APIs is available here.

Other libraries

  • EnumKit
    is a protocol-oriented, reflection-based solution to ergonomic enum access and inspired the creation of this library.

Interested in learning more?

These concepts (and more) are explored thoroughly in Point-Free, a video series exploring functional programming and Swift hosted by Brandon Williams and Stephen Celis.

The design of this library was explored in the following Point-Free episodes:

video poster image

License

All modules are released under the MIT license. See LICENSE for details.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.