Feature request: Add a Store.send(_:while:) API

[jpsim]

Similar to ViewStore.send(_:while:), it can be useful to wait for a specific state change to occur before resuming control flow.

I believe the recommendation when migrating from ViewStore.send(_:while:) to Store.send(...) is to append StoreTask.finish(), which is a much cleaner solution much of the time, when the duration of the effect from sending the action into the store is exactly tied to the operation, but isn't quite as flexible as the while predicate API from ViewStore.

For example, here it would be useful to do await store.send(.didPullToRefresh, while: \.isRefreshing), which would behave differently from await store.send(.didPullToRefresh).finish():

@Reducer
struct Feature {
  @ObservableState
  struct State: Equatable {
    var isRefreshingData1 = false
    var isRefreshingData2 = false

    var isRefreshing: Bool {
      isRefreshingData1 || isRefreshingData2
    }
  }
  enum Action { /* ... */ }

  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .didPullToRefresh:
        return .run { send in
          await send(.refreshData1)
          await send(.refreshData2)
        }
      case .refreshData1:
        state.isRefreshingData1 = true
        return .run { /* ... */ }
      case .refreshData2:
        state.isRefreshingData2 = true
        return .run { /* ... */ }
      }
    }
  }
}

[kamcma]

Could the above be refactored like so? The original implementation might be exhibiting the sharing-code-with-actions pattern.

import ComposableArchitecture
import SwiftUI

@Reducer
struct Feature {
  @ObservableState
  struct State: Equatable { }

  enum Action {
    case didPullToRefresh
    case refreshData1Returned
    case refreshData2Returned
  }

  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .didPullToRefresh:
        return .concatenate(
          .run { send in
            // ...
            await send(.refreshData1Returned)
          },
          .run { send in
            // ...
            await send(.refreshData2Returned)
          }
        )
      case .refreshData1Returned:
        return .none
      case .refreshData2Returned:
        return .none
      }
    }
  }
}

I believe any StoreTask awaited from sending .didPullToRefresh will await the whole concatenated effect.

[jpsim]

Yes, for this specific example, but it's not always possible to inline the effect like this, such as when sending an action to a child reducer.

[kamcma]

Is it possible using this technique?

[kamcma]

I guess to me it seems worth contorting yourself a bit to avoid introducing a second source of truth in state about whether an effect is in flight.

[jpsim]

Yes, exposing the effect publicly so the parent can use it directly would solve this, but is less ideal than having a Store.send(_:while:) utility.

If the child reducer is defined in a separate module, it would require exposing the effect in the module's public interface, and would also require the parent to have more knowledge about the implementation details of that child reducer.

[kamcma]

I guess I am not certain what is meant by "exposing the effect". To use the technique linked above, invoking a child reducer directly, I am not certain that anything needs to be made public beyond what must already be public to compose a child into a reducer at all: the child reducer type and its state and action types.

[stephencelis]

@jpsim Refreshable should be tied to all "child" effects spawned from the original, so I believe it already works the way you expect. You can verify in the refreshable case study by moving the refresh logic to a child action called from the parent .refresh effect.

Do you have an example of this not working?

[jpsim]

Oh yes, you're right. This is unexpected because the send() closure returns immediately without waiting for all child effects to complete.

These changes to the Refreshable case study:

diff --git a/Examples/CaseStudies/SwiftUICaseStudies/02-Effects-Refreshable.swift b/Examples/CaseStudies/SwiftUICaseStudies/02-Effects-Refreshable.swift
index 46271c04d..6b01e6d94 100644
--- a/Examples/CaseStudies/SwiftUICaseStudies/02-Effects-Refreshable.swift
+++ b/Examples/CaseStudies/SwiftUICaseStudies/02-Effects-Refreshable.swift
@@ -26,6 +26,7 @@ struct Refreshable {
     case factResponse(Result<String, Error>)
     case incrementButtonTapped
     case refresh
+    case fetchFact(Int)
   }
 
   @Dependency(\.factClient) var factClient
@@ -42,6 +43,7 @@ struct Refreshable {
         return .none
 
       case let .factResponse(.success(fact)):
+        print("Received \(action)")
         state.fact = fact
         return .none
 
@@ -56,12 +58,22 @@ struct Refreshable {
       case .refresh:
         state.fact = nil
         return .run { [count = state.count] send in
+          print("Will send fetchFact action")
+          await send(.fetchFact(count))
+          print("Did send fetchFact action")
+        }
+        .cancellable(id: CancelID.factRequest)
+      case .fetchFact(let count):
+        return .run { send in
+          print("Starting \(action)")
+          try await Task.sleep(for: .seconds(5))
           await send(
             .factResponse(Result { try await self.factClient.fetch(count) }),
             animation: .default
           )
+          try await Task.sleep(for: .seconds(5))
+          print("Finished \(action)")
         }
-        .cancellable(id: CancelID.factRequest)
       }
     }
   }
@@ -109,7 +121,9 @@ struct RefreshableView: View {
     .refreshable {
       isLoading = true
       defer { isLoading = false }
+      print("Refresh started")
       await store.send(.refresh).finish()
+      print("Refresh finished")
     }
   }
 }

Logs the following:

Refresh started
Will send fetchFact action
Did send fetchFact action
Starting fetchFact(0)
Received factResponse(Swift.Result<Swift.String, Swift.Error>.success("0 is the atomic number of the theoretical element tetraneutron."))
Finished fetchFact(0)
Refresh finished

So with this in mind, I don't think I need Store.send(_:while:) anymore and can simply use .finish().