Rename some generics in the store rescoping. (#1320)

(cherry picked from commit 2fe78298e3d1d6693d3c83054bb8487c84ec516a)

# Conflicts:
#	Sources/ComposableArchitecture/Store.swift

Author: mbrandonw

Sources/ComposableArchitecture/Effect.swift

@@ -56,6 +56,7 @@ public struct Effect<Output, Failure: Error> {
 extension Effect {
   /// An effect that does nothing and completes immediately. Useful for situations where you must
   /// return an effect, but you don't need to do anything.
+  @inlinable
   public static var none: Self {
     Self(operation: .none)
   }

Sources/ComposableArchitecture/Store.swift

@@ -549,48 +549,44 @@ public final class Store<State, Action> {
 }
 
 private protocol AnyScope {
-  func rescope<State, Action, ChildState, ChildAction>(
-    _ store: Store<State, Action>,
-    state toNewChildState: @escaping (State) -> ChildState,
-    action fromNewChildAction: @escaping (ChildAction) -> Action
-  ) -> Store<ChildState, ChildAction>
+  func rescope<ScopedState, ScopedAction, RescopedState, RescopedAction>(
+    _ store: Store<ScopedState, ScopedAction>,
+    state toRescopedState: @escaping (ScopedState) -> RescopedState,
+    action fromRescopedAction: @escaping (RescopedAction) -> ScopedAction
+  ) -> Store<RescopedState, RescopedAction>
 }
 
 private struct Scope<RootState, RootAction>: AnyScope {
   let root: Store<RootState, RootAction>
-  let toChildState: Any
-  let fromChildAction: Any
+  let fromScopedAction: Any
 
   init(root: Store<RootState, RootAction>) {
-    self.init(root: root, toChildState: { $0 }, fromChildAction: { $0 })
+    self.init(root: root, fromScopedAction: { $0 })
   }
 
-  private init<State, Action>(
+  private init<ScopedAction>(
     root: Store<RootState, RootAction>,
-    toChildState: @escaping (RootState) -> State,
-    fromChildAction: @escaping (Action) -> RootAction
+    fromScopedAction: @escaping (ScopedAction) -> RootAction
   ) {
     self.root = root
-    self.toChildState = toChildState
-    self.fromChildAction = fromChildAction
+    self.fromScopedAction = fromScopedAction
   }
 
-  func rescope<State, Action, ChildState, ChildAction>(
-    _ store: Store<State, Action>,
-    state toChildState: @escaping (State) -> ChildState,
-    action fromChildAction: @escaping (ChildAction) -> Action
-  ) -> Store<ChildState, ChildAction> {
-    let toState = self.toChildState as! (RootState) -> State
-    let fromAction = self.fromChildAction as! (Action) -> RootAction
-
+  func rescope<ScopedState, ScopedAction, RescopedState, RescopedAction>(
+    _ scopedStore: Store<ScopedState, ScopedAction>,
+    state toRescopedState: @escaping (ScopedState) -> RescopedState,
+    action fromRescopedAction: @escaping (RescopedAction) -> ScopedAction
+  ) -> Store<RescopedState, RescopedAction> {
+    let fromScopedAction = self.fromScopedAction as! (ScopedAction) -> RootAction
+    
     var isSending = false
-    let childStore = Store<ChildState, ChildAction>(
-      initialState: toChildState(store.state),
-      reducer: .init { childState, childAction, _ in
+    let rescopedStore = Store<RescopedState, RescopedAction>(
+      initialState: toRescopedState(scopedStore.state),
+      reducer: .init { rescopedState, rescopedAction, _ in
         isSending = true
         defer { isSending = false }
-        let task = self.root.send(fromAction(fromChildAction(childAction)))
-        childState = toChildState(store.state)
+        let task = self.root.send(fromScopedAction(fromRescopedAction(rescopedAction)))
+        rescopedState = toRescopedState(scopedStore.state)
         if let task = task {
           return .fireAndForget { await task.cancellableValue }
         } else {
@@ -599,17 +595,16 @@ private struct Scope<RootState, RootAction>: AnyScope {
       },
       environment: ()
     )
-    childStore.parentDisposable = store.producer
+    scopedStore.parentDisposable = scopedStore.producer
       .skip(first: 1)
-      .startWithValues { [weak childStore] newValue in
+      .startWithValues { [weak rescopedStore] newValue in
         guard !isSending else { return }
-        childStore?.state = toChildState(newValue)
+        rescopedStore?.state = toRescopedState(newValue)
       }
-    childStore.scope = Scope<RootState, RootAction>(
+    rescopedStore.scope = Scope<RootState, RootAction>(
       root: self.root,
-      toChildState: { toChildState(toState($0)) },
-      fromChildAction: { fromAction(fromChildAction($0)) }
+      fromScopedAction: { fromScopedAction(fromRescopedAction($0)) }
     )
-    return childStore
+    return rescopedStore
   }
 }