Concise Forms: Bye Bye Boilerplate

Exercises

1. Loosen the Hashable constraint on FormAction’s erased Value generic to Equatable by implementing an AnyEquatable type eraser, such that AnyEquatable(myEquatableValue) should compile.

   Solution

   We can implement AnyEquatable using erasure in a similar way to how we did with FormAction: by erasing the given value and holding onto a function that captures the equatable conformance. Then, we can introduce a generic initializer that enforces things safely.

   struct AnyEquatable: Equatable {
     let value: Any
     let valueIsEqualTo: (Any) -> Bool
   
     init<Value>(_ value: Value) where Value: Equatable {
       self.value = value
       self.valueIsEqualTo = { $0 as? Value == value }
     }
   
     static func == (lhs: Self, rhs: Self) -> Bool {
       lhs.valueIsEqualTo(rhs.value)
     }
   }
   

   Now we can update FormAction to be initialized with an Equatable constraint instead of a Hashable constraint by holding the value in an AnyEquatable instead of AnyHashable:

   struct FormAction<Root>: Equatable {
     let keyPath: PartialKeyPath<Root>
     let value: AnyEquatable
     let setter: (inout Root) -> Void
   
     init<Value>(
       _ keyPath: WritableKeyPath<Root, Value>,
       _ value: Value
     ) where Value: Equatable {
       self.keyPath = keyPath
       self.value = AnyEquatable(value)
       self.setter = { $0[keyPath: keyPath] = value }
     }
   
     static func set<Value>(
       _ keyPath: WritableKeyPath<Root, Value>,
       _ value: Value
     ) -> Self where Value: Equatable {
       self.init(keyPath, value)
     }
     …
   }
   

   This lets us update the view store binding helper, as well:

   extension ViewStore {
     func binding<Value>(
       keyPath: WritableKeyPath<State, Value>,
       send action: @escaping (FormAction<State>) -> Action
     ) -> Binding<Value> where Value: Equatable {
       self.binding(
         get: { $0[keyPath: keyPath] },
         send: { action(.init(keyPath, $0)) }
       )
     }
   }
   

   Now we can even drop the Hashable constraing on AlertState and everything still compiles!