Case Paths for Free

Exercises

1. In the Composable Architecture we have been building, the pullback operation on reducers took two transformations: a writable key path for state and a writable key path for actions. Replace the key path on actions with a case path, and update the project to use this new API.

   Solution

   public func pullback<LocalValue, GlobalValue, LocalAction, GlobalAction>(
     _ reducer: @escaping Reducer<LocalValue, LocalAction>,
     value: WritableKeyPath<GlobalValue, LocalValue>,
     action: CasePath<GlobalAction, LocalAction>
   ) -> Reducer<GlobalValue, GlobalAction> {
     return { globalValue, globalAction in
       guard let localAction = action.extract(globalAction) else { return [] }
       let localEffects = reducer(&globalValue[keyPath: value], localAction)
   
       return localEffects.map { localEffect in
         localEffect.map(action.embed).eraseToEffect()
       }
     }
   }
   

2. Our reflection-based case path initializer is relatively simple, but it’s also relatively brittle: there are several edge cases that it will fail to work with. The next few exercises will explore finding solutions to these edge cases.

   For one, given the following enum with a labeled case.

   enum EnumWithLabeledCase {
     case labeled(label: Int)
   }
   

   Extraction fails:

   extractHelp(
     case: EnumWithLabeledCase.labeled,
     from: EnumWithLabeledCase.labeled(label: 1)
   )
   // nil
   

   Study the mirror of EnumWithLabeledCase.labeled(label: 1) and update extractHelp with the capability of extracting this value.

   Note that it is perfectly valid Swift to add a second case to this enum with the same name but a different label:

   enum EnumWithLabeledCase {
     case labeled(label: Int)
     case labeled(anotherLabel: Int)
   }
   

   Ensure that extractHelp fails to extract this mismatch:

   Solution

   EnumWithLabeledCase.labeled(label: 1) has a single child with an unusual value:

   let labeled = EnumWithLabeledCase.labeled(label: 1)
   let children = Mirror(reflecting: labeled).children
   children.count  // 1
   children.first! // (label: "labeled", value: (label: 1))
   

   Strange! The Mirror.Child has a label matching the case name, but its value appears to be a tuple of one labeled element, something that’s typically forbidden in Swift. It’s important to note that the tuple label matches the associated value’s label.

   In order to interact with this structure, we must again reflect.

   let newChildren = Mirror(reflecting: children.first!.value)
   newChildren.count  // 1
   newChildren.first! // (label: "label", value: 1)
   

   Alright, this should be enough for us to update extractHelp to do just a little more work. We want to dive one step further into the structure, so let’s extract that work into a helper function in order to perform it twice.

   func extractHelp<Root, Value>(
     case: @escaping (Value) -> Root,
     from root: Root
   ) -> Value? {
     func reflect(_ root: Root) -> ([String?], Value)? {
       let mirror = Mirror(reflecting: root)
       guard let child = mirror.children.first else { return nil }
       if let value = child.value as? Value { return ([child.label], value) }
   
       let newMirror = Mirror(reflecting: child.value)
       guard let newChild = newMirror.children.first else { return nil }
       if let value = newChild.value as? Value { return ([child.label, newChild.label], value) }
   
       return nil
     }
   
     guard let (path, value) = reflect(root) else { return nil }
     guard let (newPath, _) = reflect(`case`(value)) else { return nil }
     guard path == newPath else { return nil }
   
     return value
   }