Use of publisherScope(state:)

[gonzalonunez]

Hi!

Writing because I use publisherScope(state:). I use it for a Store+IfUnique.swift extension that is as follows:

import Combine
import ComposableArchitecture

extension Store {
  
  /// Subscribes to updates when a store containing identifiable state changes – the id is used to
  /// describe that state has changed
  ///
  /// This is useful for handling navigation in a UISplitViewController, where you don't quite want what
  /// `ifLet` does if you can select two different instances of a detail state. Take, for example, a case
  /// where we can select the "Community" tab for a list of Clubs in a sidebar:
  ///
  ///     class MasterViewController: UIViewController {
  ///       let store: Store<MasterState, MasterAction>
  ///       var cancellables: Set<AnyCancellable> = []
  ///       ...
  ///       func viewDidLoad() {
  ///         ...
  ///         store
  ///           .scope(state: { $0.detailState }, action: MasterAction.detail)
  ///           .ifUnique { [weak self, makeNavigationController] detailStore in
  ///             let rootViewController = DetailViewController(store: detailStore)
  ///             let navigationController = NavigationController(rootViewController: rootViewController)
  ///             self?.showDetailViewController(navigationController, sender: self)
  ///           }
  ///           .store(in: cancellables)
  ///       }
  ///     }
  public func ifUnique(
    then receiveValue: @escaping (Store<State, Action>) -> Void) -> Cancellable where State: Identifiable
  {
    let cancellable = self
      .publisherScope(state: { $0.removeDuplicates { $0.id == $1.id }})
      .sink(receiveValue: receiveValue)

    return AnyCancellable {
      cancellable.cancel()
    }
  }
  
  /// Identical to the `ifUnique` that operates on non-optionals except also handles optional state,
  /// the same way `ifLet` does.
  public func ifUnique<Wrapped: Identifiable>(
    then receiveValue: @escaping (Store<Wrapped, Action>) -> Void) -> Cancellable where State == Wrapped?
  {
    let cancellable = self
      .publisherScope(state: { state in
        state
          .removeDuplicates { $0?.id == $1?.id }
          .compactMap { $0 }
      })
      .sink(receiveValue: receiveValue)

    return AnyCancellable {
      cancellable.cancel()
    }
  }
}

[gonzalonunez]

I wrote this a looong time ago. Happy to follow whatever course of action you all think is best, if there's another way 🙌

[iampatbrown]

I'd say either use .ifLet inside .sink { ... }

.sink { [weak self] _ in
  guard let self = self else { return }
  _ = self.store.scope(state: \.child, action: Action.child)
    .ifLet(then: self.setNavigation(store:))
}
.store(in: &cancellables)

or maybe add an extension to store that uses .ifLet so you can guard against optional state.

extension Store {
  func unwrap<Wrapped>() -> Store<Wrapped, Action>? where State == Wrapped? {
    var unwrapped: Store<Wrapped, Action>?
    _ = self.ifLet { unwrapped = $0 }
    return unwrapped
  }
}

.sink { [weak self] _ in
  guard
    let self = self,
    let childStore = self.store.scope(state: \.child, action: Action.child).unwrap()
  else { return }
  ...
}
.store(in: &cancellables)

I'll jump on a bit latter and see if I can recreate your ifUnique extensions

[iampatbrown]

@gonzalonunez Can you test these out for me?

extension Store {
  public func ifUnique(
    then receiveValue: @escaping (Store<State, Action>) -> Void
  ) -> Cancellable where State: Identifiable {
    ViewStore(self.scope(state: \.id))
      .publisher
      .sink { [weak self] _ in
        guard let self = self else { return }
        receiveValue(self)
      }
  }

  public func ifUnique<Wrapped: Identifiable>(
    then receiveValue: @escaping (Store<Wrapped, Action>) -> Void
  ) -> Cancellable where State == Wrapped? {
    ViewStore(self.scope(state: \.?.id))
      .publisher
      .compactMap { $0 }
      .sink { [weak self] _ in
        guard let self = self else { return }
        _ = self.ifLet(then: receiveValue)
      }
  }
}

[gonzalonunez]

@iampatbrown looks like these work! Makes perfect sense to me 🎉

Random question, now that we're here – is there a cost to creating ViewStores casually like this? I do this in a few other places too, but just curious. Thanks for your help!

[iampatbrown]

There is a cost for sure. I'd say creating a new ViewStore vs publisherScope would be similar. Doing self.viewStore.send(action) would probably be twice as fast as ViewStore(self.store).send(action) not that bad depending on what you're using it for.

If we didn't have to use ViewStore you could subscribe directly to self.state. You could also use a closure instead of a KeyPath for slightly better performance. That would make your extensions look something like this:

extension Store {
  public func ifUnique(
    then receiveValue: @escaping (Store<State, Action>) -> Void
  ) -> Cancellable where State: Identifiable {
    self.state.map { $0.id }
      .removeDuplicates()
      .sink { [weak self] _ in
        guard let self = self else { return }
        receiveValue(self)
      }
  }

  public func ifUnique<Wrapped: Identifiable>(
    then receiveValue: @escaping (Store<Wrapped, Action>) -> Void
  ) -> Cancellable where State == Wrapped? {
    self.state.compactMap { $0?.id }
      .removeDuplicates()
      .sink { [weak self] _ in
        guard let self = self else { return }
        _ = self.ifLet(then: receiveValue)
      }
  }
}

[gonzalonunez]

Got it! Nice, thanks for the help @iampatbrown 🙌