Composing Architecture with Case Paths

Exercises

1. In this week’s episode let’s explore more real world applications of case paths.

   SwiftUI introduces a Binding type, which is a getter-setter pair that isn’t so different from a writable key path, and in fact has an operation that takes a key path from the binding’s root to a value that returns a new binding for the value.

   Is it possible to define this operation for case paths?

   extension Binding {
     subscript<Subject>(
       casePath: CasePath<Value, Subject>
     ) -> Binding<Subject> {
       fatalError("unimplemented")
     }
   }
   

   Solution

   Any implementation of this function will be unsafe: case path extraction results in an optionally failable operation, which means the get function of the binding would need to force unwrap the value,

2. Implement the following function, which is similar to the previous exercise, but optionalizes the returned binding.

   extension Binding {
     subscript<Subject>(
       casePath: CasePath<Value, Subject>
     ) -> Binding<Subject>? {
       fatalError("unimplemented")
     }
   }
   

   Solution

   extension Binding {
     subscript<Subject>(
       casePath: CasePath<Value, Subject>
     ) -> Binding<Subject>? {
       casePath.extract(from: self.wrappedValue).map { subject in
         Binding<Subject>(
           get: { subject },
           set: { self.wrappedValue = casePath.embed($0) }
         )
       }
     }
   }
   

3. While we typically model application state using structs, it is totally valid to model application state using enums. For example, your root state may be an enumeration of logged-in and logged-out states:

   enum AppState {
     case loggedIn(LoggedInState)
     case loggedOut(LoggedOutState)
   }
   

   Use the case path helper from the previous exercise and define a root AppView that works with AppState and renders a LoggedInView or LoggedOutView with a Binding for their state.

   Solution

   struct LoggedInView: View {
     @Binding var state: LoggedInState
   
     var body: some View {
       EmptyView()
     }
   }
   
   struct LoggedOutView: View {
     @Binding var state: LoggedOutState
   
     var body: some View {
       EmptyView()
     }
   }
   
   struct AppView: View {
     @Binding var state: AppState
   
     var body: some View {
       if let loggedInBinding = self.$state[/AppState.loggedIn] {
         return AnyView(LoggedInView(state: loggedInBinding))
       } else if let loggedOutBinding = self.$state[/AppState.loggedOut] {
         return AnyView(LoggedOutView(state: loggedOutBinding))
       } else {
         return AnyView(EmptyView())
       }
     }
   }
   

4. The previous exercises introduce a case path helper analog to a key path helper that uses dynamic member lookup. Theorize how a first-class case path dynamic member lookup API would look like in Swift.

5. Combine defines a key path API for reactive bindings:

   extension Publisher where Failure == Never {
     func assign<Root>(
       to keyPath: ReferenceWritableKeyPath<Root, Output>,
       on object: Root
     ) -> AnyCancellable
   }
   

   What would it take to define an equivalent API that takes case paths?

   Solution

   This API depends on a “reference-writable” key path in order to capture the reference to an object to be mutated later. Case paths, however, typically describe enums, which are value types, which cannot be mutated in the same way. For a function to mutate a value, the value must be annotated with inout and this mutable value cannot be captured for mutation later.

6. Swift defines a key path API for key-value observing:

   extension NSObject {
     func observe<Value>(
       keyPath: KeyPath<Self, Value>,
       options: NSKeyValueObservingOptions,
       changeHandler: @escaping (Self, NSKeyValueObservedChange<Value>) -> Void
     )
   }
   

   What would it take to define an equivalent API that takes case paths?

   Solution

   Swift’s key-value observing APIs depends on the Objective-C runtime, and the method that takes key paths is based on a more primitive method that uses the property’s name to observe changes to the property. Swift enums are not portable to Objective-C, so no such API can exist today.

7. Take additional, existing APIs that take key paths and explore their case path equivalents! And share them with us!