Convenience for observing an action-only ViewStore with no state

[Jeehut]

I'm in the middle of cleaning up my project and migrating over to the Reducer protocol & modern navigation (TCA 1.0). While doing that, I found myself in a situation where I extracted some SwiftUI code into a helper function which needed to be able to send back actions, but that doesn't need to observe any state.

In particular, the situation was the .commands modifier on a WindowGroup like this:

   var body: some Scene {
      WindowGroup("Projects Browser") {
         WithViewStore(self.store, observe: \.projectsBrowserWindow) { viewStore in
            ProjectsBrowserView(store: self.store.scope(state: \.childProjectsBrowser, action: AppFeature.Action.childProjectsBrowser))
               .background(
                  WindowAccessor(
                     isAuxiliary: false, isResizable: false,
                     window: viewStore.binding(get: \.optional, send: AppFeature.Action.projectsBrowserWindowPresented)
                  )
               )
         }
      }
      .windowStyle(.hiddenTitleBar)
      .commands {
         self.commands(viewStore: ViewStore(self.store, observe: { /* ??? */ })
      }
   }

I wasn't sure how to specify in the observe: parameter that I don't need any state at all. Also, I need to specify a ViewStore type for the parameter passed to my helper function, but it wasn't clear what to use there:

func commands(viewStore: ViewStoreOf<???>) -> some Commands

Returning () didn't work (as it's not Equatable), so I figured I'd need to provide an empty state type and initialize it here. Then I thought, this might be useful in other places as well, basically whenever a ViewStore is created for the sole purpose of providing a way to send actions into the system, such as an extracted view with only buttons.

So I created a NoState type and also some convenience along it to make specifying a type for the parameter easy, too:

/// A `ViewStore` that has no state, only actions.
public typealias ActionViewStore<ViewAction> = ViewStore<NoState, ViewAction>

/// Convenience helper to declare a `ViewStore` that has no state, only actions.
public typealias ActionViewStoreOf<R: Reducer> = ActionViewStore<R.Action>

/// A type representing empty state.
public struct NoState: Equatable {}

extension Equatable {
   /// Useful as a keypath to observe nothing in a `State` when building a `WithViewStore` using `ComposableArchitecure`.
   public var nothing: NoState { NoState() }
}

With this code, specifying and calling an extracted helper function is as easy as:

// SwiftUI code
.commands {
   self.commands(viewStore: ViewStore(self.store, observe: \.nothing))
}

// helper function
func commands(viewStore: ActionViewStoreOf<AppFeature>) -> some Commands

What do you think? Did I overlook a much easier solution to my problem? If not, is there any interest in including this into TCA directly and shipping it as built-in types? If yes, I'd be available to add more documentation and send a PR. Else, feel free to copy & paste if you need it as well.

P.S. I considered noState for the name of the computed property instead of nothing, which might be confusing when available on all Equatable types. If you know a better way to provide it only in the context of states, I could restrict it that way. If there's no better idea, we should maybe rename the property to noState when shipped as part of the lib.

[tgrapperon]

Hey @Jeehut! As an alternative, there is a stateless property on Store that scopes a store onto a Void state.
The is also a PR that should make this procedure even more lightweight, as you will be able to directly send actions to some unsafeStore.

Returning () didn't work (as it's not Equatable)

Please also note that you can define the removeDuplicate argument to deduplicate states yourself. But this shouldn't be required for stateless stores (nor the observe argument).

[Jeehut]

@tgrapperon Of course, there was already a solution for this. I'm using this now:

// SwiftUI code
.commands {
   self.commands(viewStore: ViewStore(self.store.stateless))
}

// helper function
func commands(viewStore: ViewStore<Void>) -> some Commands

Thank you for the quick response & clarification!

[Jeehut]

Oh, wait, that didn't compile. I had to actually define the typealiases for convenience, it seems:

/// A `ViewStore` that has no state, only actions.
public typealias StatelessViewStore<ViewAction> = ViewStore<Void, ViewAction>

/// Convenience helper to declare a `ViewStore` that has no state, only actions.
public typealias StatelessViewStoreOf<R: Reducer> = StatelessViewStore<R.Action>

This way I can declare the helper function as:

func commands(viewStore: StatelessViewStoreOf<AppFeature>) -> some Commands