ComposablePresents - improved presentation and navigation?

[rcarver]

Hi all - I had an idea for how to model presentation/navigation (optional state and effects) and it's looking promising.

https://github.com/rcarver/composable-presents

It takes some of my favorite ideas from ComposablePresentation, SwiftUINavigation, and TCA's BindableState and adds a proper domain model for transitioning between states. That's all hidden behind a simple property wrapper and higher order reducer.

I haven't put it to the test in my real app yet, but the test suite and included example app are feeling really good. I wanted to get smarter people's eyes on it for feedback and interest before going further.

Thanks to @mbrandonw and @stephencelis for providing such a solid foundation, I hope this can add something to the space!

---

Here's a full example from the README. Check out the examples and tests for more usage. See also background and goals for more context.

The child/presented domain —

struct PersonState: Equatable {
  var name: String
  var age: Int
}

// 🎁 Action implements `LongRunningAction`, allowing it to be used
// directly as a presenter.
enum PersonAction: Equatable, LongRunningAction {
  case begin
  case cancel
  case setAge(Int)
}

struct PersonEnvironment {
  var years: () -> Effect<Int, Never>
  var mainQueue: AnySchedulerOf<DispatchQueue>
}

enum PersonEffect {}

let personReducer = Reducer<PersonState, PersonAction, PersonEnvironment>.combine(
  Reducer { state, action, environment in
    switch action {
    case .setAge(let age):
      state.age = age
      return .none
  
    // 🎁 For `LongRunningAction`, start any effects.
    case .begin:
      return environment.years()
        .receive(on: environment.mainQueue)
        .eraseToEffect(PersonAction.setAge)
        .cancellable(id: PersonEffect.self)
        
    // 🎁 For `LongRunningAction`, cancel any effects.
    case .cancel:
      return .cancel(id: PersonEffect.self)
    }
  }
)

The parent/presenter domain —

struct WorldState: Equatable {
  // 🎁 Property wrapper for presenting any state
  @PresentsAny var person: PersonState?
}

enum WorldAction: Equatable {
  case born
  case died
  case person(PersonAction)
}

struct WorldEnvironment {
  var years: () -> Effect<Int, Never>
  var mainQueue: AnySchedulerOf<DispatchQueue>
  var person: PersonEnvironment { .init(years: years, mainQueue: mainQueue) }
}

let reducer = Reducer<WorldState, WorldAction, WorldEnvironment>.combine(
  // 👀 Optional pullback, independent of presentation.
  personReducer.optional().pullback(
    state: \.person,
    action: /WorldAction.person,
    environment: \.person
  ),
  Reducer { state, action, environment in
    switch action {
    case .born:
      // 🎁 Set state to an honest value, triggering presentation 
      state.person = .init(name: "John", age: 0)
      return .none
    case .died:
      // 🎁 Set state to an nil value, triggering dismissal
      state.person = nil
      return .none
    case .person:
      return .none
    }
  }
    // 🎁 Attach `presents` reducer to property wrapper.
    .presents(
      state: \.$person,
      action: /WorldAction.person,
      environment: \.person,
      // 🎁 Convert `personReducer` to `Presenter` because it 
      // implements `LongRunningAction`
      presenter: .longRunning(personReducer)
    )
)

[stephencelis]

@rcarver Very cool stuff, thanks for sharing! Looking forward to diving into it.

We have plans on the horizon to provide better navigation support directly in TCA (we've been refining our ideas for awhile, but they are finally coming together), and from a quick look it seems like some of our ideas overlap with yours! Your explorations will surely further inspire us 😄

[rcarver]

Thanks @stephencelis that's great to hear! I'm really just following your patterns so it's very cool that we're moving in the same direction. Looking forward to seeing what you come up with!