Rename reduce into mutate

Author: Alex Usbergo

README.md

@@ -48,16 +48,16 @@ enum CounterAction: Action {
   case increase
   case decrease
 
-  func reduce(context: TransactionContext<Store<Counter>, Self>) {
+  func mutate(context: TransactionContext<Store<Counter>, Self>) {
     defer {
       // Remember to always call `fulfill` to signal the completion of this operation.
       context.fulfill()
     }
     switch self {
     case .increase(let amount):
-      context.reduceModel { $0.count += 1 }
+      context.update { $0.count += 1 }
     case .decrease(let amount):
-      context.reduceModel { $0.count -= 1 }
+      context.update { $0.count -= 1 }
     }
   }
 
@@ -71,12 +71,12 @@ Or a struct:
 struct IncreaseAction: Action {
   let count: Int
 
-  func reduce(context: TransactionContext<Store<Counter>, Self>) {
+  func mutate(context: TransactionContext<Store<Counter>, Self>) {
     defer {
       // Remember to always call `fulfill` to signal the completion of this operation.
       context.fulfill()
     }
-    context.reduceModel { $0.count += 1 }
+    context.mutate { $0.count += 1 }
   }
 
   func cancel(context: TransactionContext<Store<Counter>, Self>) { }
@@ -97,15 +97,15 @@ enum CounterAction: Action {
   case increase(amount: Int)
   case decrease(amount: Int)
 
-  func reduce(context: TransactionContext<Store<Counter>, Self>) {
+  func mutate(context: TransactionContext<Store<Counter>, Self>) {
     defer {
       context.fulfill()
     }
     switch self {
     case .increase(let amount):
-      context.reduceModel { $0.count += amount }
+      context.update { $0.count += amount }
     case .decrease(let amount):
-      context.reduceModel { $0.count -= amount }
+      context.update { $0.count -= amount }
     }
   }
 
@@ -139,7 +139,7 @@ struct ContentView_Previews : PreviewProvider {
 
 ### `class Store<M>: ObservableObject, Identifiable`
 
-This class is the default implementation of the `ReducibleStore` protocol.
+This class is the default implementation of the `MutableStore` protocol.
 A store wraps a value-type model, synchronizes its mutations, and emits notifications to its
 observers any time the model changes.
 
@@ -174,9 +174,7 @@ e.g.
  `Toggle("...", isOn: $store.binding.someProperty)`.
  When the binding set a new value an implicit action is being triggered and the property is
  updated.
- 
-* ` func reduceModel(transaction: AnyTransaction?, closure: (inout ModelType) -> Void)`
-Atomically update the model and notifies all of the observers.
+
 
  ### Observation
 

Sources/Store/action/Action.swift

@@ -7,19 +7,18 @@ import OpenCombine
 import OpenCombineDispatch
 #endif
 
-
 /// An action represent an operation on the store.
 public protocol Action: Identifiable {
 
-  associatedtype AssociatedStoreType: ReducibleStore
+  associatedtype AssociatedStoreType: MutableStore
 
   /// Unique action identifier.
   /// An high level description of the action (e.g. `FETCH_USER` or `DELETE_COMMENT`)
   var id: String { get }
 
   /// The execution body for this action.
   /// - note: Invoke `context.operation.finish` to signal task completion.
-  func reduce(context: TransactionContext<AssociatedStoreType, Self>)
+  func mutate(context: TransactionContext<AssociatedStoreType, Self>)
 
   /// Used to implement custom cancellation logic for this action.
   /// E.g. Stop network transfer.
@@ -55,81 +54,121 @@ extension Action {
 ///
 /// ```
 @propertyWrapper public final class CancellableStorage {
+
     public var wrappedValue: AnyCancellable?
 
     public init(wrappedValue: AnyCancellable? = nil) {
         self.wrappedValue = wrappedValue
     }
 }
 
-/// Reduce the model by using the closure passed as argument.
-public struct Reduce<M>: Action {
+// MARK: - Mutate
+
+extension Store {
+  
+  /// Mutate the model with the closure passed as argument.
+  public func mutate(
+    id: String = _ID.mutate,
+    mode: Executor.Mode = .sync,
+    mutate: @escaping (inout M) -> Void
+  ) {
+    let action = Mutate(id: id, mutate: mutate)
+    run(action: action, mode: mode)
+  }
+}
+
+/// Mutate the model by using the closure passed as argument.
+public struct Mutate<M>: Action {
+  
   public let id: String
-  public let reduce: (inout M) -> Void
+  public let mutate: (inout M) -> Void
 
-  public init(id: String = _ID.reduce, reduce: @escaping (inout M) -> Void) {
+  public init(id: String = _ID.mutate, mutate: @escaping (inout M) -> Void) {
     self.id = id
-    self.reduce = reduce
+    self.mutate = mutate
   }
 
-  public func reduce(context: TransactionContext<Store<M>, Self>) {
+  public func mutate(context: TransactionContext<Store<M>, Self>) {
     defer {
       context.fulfill()
     }
-    context.reduceModel(closure: reduce)
+    context.update(closure: mutate)
   }
 
   public func cancel(context: TransactionContext<Store<M>, Self<M, V>>) { }
 }
 
+// MARK: - Assign
+
+extension Store {
+
+  /// Mutate the model at the target key path passed as argument.
+  public func mutate<V>(
+    keyPath: WritableKeyPath<M, V>,
+    value: V,
+    mode: Executor.Mode = .sync
+  ) {
+    let action = Assign(keyPath, value)
+    run(action: action, mode: mode)
+  }
+  
+  /// Synchronously mutate the model at the target key path passed as argument.
+  public func mutateSynchronous<V>(keyPath: WritableKeyPath<M, V?>, value: V?) {
+    let action = Assign(keyPath, value)
+    run(action: action, mode: .sync)
+  }
+}
+
 /// Assigns the value passed as argument to the model's keyPath.
 public struct Assign<M, V>: Action {
+  
   public let id: String
-  public let keyPath: KeyPathArg<M, V>
-  public let value: V?
 
-  public init(id: String = _ID.assign, _ keyPath: KeyPathArg<M, V>, _ value: V) {
-    self.id = id
+  private let value: V?
+  private let keyPath: KeyPathTarget<M, V>
+
+  private init(_ keyPath: KeyPathTarget<M, V>, _ value: V) {
+    self.id = _ID.assign
     self.keyPath = keyPath
     self.value = value
   }
 
-  public init(id: String = _ID.assign, _ keyPath: WritableKeyPath<M, V>, _ value: V) {
-    self.id = "\(id)[\(keyPath.readableFormat ?? "unknown")]"
+  public init(_ keyPath: WritableKeyPath<M, V>, _ value: V) {
+    self.id = "\(_ID.assign)[\(keyPath.readableFormat ?? "unknown")]"
     self.keyPath = .value(keyPath: keyPath)
     self.value = value
   }
 
-  public init(id: String = _ID.assign,_ keyPath: WritableKeyPath<M, V?>, _ value: V?) {
-    self.id = "\(id)[\(keyPath.readableFormat ?? "unknown")]"
+  public init(_ keyPath: WritableKeyPath<M, V?>, _ value: V?) {
+    self.id = "\(_ID.assign)[\(keyPath.readableFormat ?? "unknown")]"
     self.keyPath = .optional(keyPath: keyPath)
     self.value = value
   }
 
-  public func reduce(context: TransactionContext<Store<M>, Self>) {
+  public func mutate(context: TransactionContext<Store<M>, Self>) {
     defer {
       context.fulfill()
     }
-    context.reduceModel { model in
+    context.update { model in
       _assignKeyPath(object: &model, keyPath: keyPath, value: value)
     }
   }
 
   public func cancel(context: TransactionContext<Store<M>, Self<M, V>>) { }
 }
 
-// MARK: - Internal
+// MARK: - Private
+
+private enum KeyPathTarget<M, V> {
 
-public enum KeyPathArg<M, V> {
   /// A non-optional writeable keyPath.
   case value(keyPath: WritableKeyPath<M, V>)
+  
   /// A optional writeable keyPath.
   case optional(keyPath: WritableKeyPath<M, V?>)
 }
 
-// MARK: - Private
-
-private func _assignKeyPath<M, V>(object: inout M, keyPath: KeyPathArg<M, V>, value: V?) {
+private func _assignKeyPath<M, V>(object: inout M, keyPath: KeyPathTarget<M, V>, value: V?) {
   switch keyPath {
   case .value(let keyPath):
     guard let value = value else { return }
@@ -142,6 +181,6 @@ private func _assignKeyPath<M, V>(object: inout M, keyPath: KeyPathArg<M, V>, va
 // MARK: - IDs
 
 public struct _ID {
-  public static let reduce = "_REDUCE"
-  public static let assign = "_BINDING_ASSIGN"
+  public static let mutate = "MUTATE"
+  public static let assign = "BINDING_ASSIGN"
 }

Sources/Store/action/FetchedProperty.swift

@@ -16,11 +16,12 @@ public extension KeyPath {
       assertionFailure()
       return nil
     }
-  
+
     let typeDescriptor = metadata.pointee.typeDescriptor
     let numberOfFields = Int(typeDescriptor.pointee.numberOfFields)
-    let offsets = typeDescriptor.pointee.offsetToTheFieldOffsetVector
-      .buffer(metadata: typePtr, count: numberOfFields)
+    let offsets = typeDescriptor.pointee.offsetToTheFieldOffsetVector.buffer(
+      metadata: typePtr,
+      count: numberOfFields)
 
     guard let fieldIndex = offsets.firstIndex(of: Int32(offset)) else {
       return nil
@@ -32,7 +33,7 @@ public extension KeyPath {
   }
 }
 
-// MARK: - Internal Layout
+// MARK: - Memory Layout
 
 private struct StructMetadata {
   var _kind: Int