Reducer to snapshot substate

[ibrahimkteish]

Imagine we have the following:

struct ParentReducer: ReducerProtocol {
  struct State: Equatable {
    var prop1: ...
    var prop2: ....
    var childState: ChildReducer.State?
  }
  
  enum Action: Equatable {
    case action1
    case action2
    case .childAction(ChildReducer.Action)
  }
  
  var body: some ReduceProtocol<State, Action> {
    Reduce { state, action in ... }
    .ifLet(\.childState, action: /Action.childAction) {
      ChildReducer()
    }
}

Imaging that the ChildReducer we are editing some properties then submitting a network request.

struct ChildReducer: ReducerProtocol {
  struct State: Equatable {
    var prop1: ...
    var prop2: ....
    var shouldSendRequest: Bool
  }
  
  enum Action: Equatable {
    case action1
    case action2
    case sendButtonTapped
  }
  
  var body: some ReduceProtocol<State, Action> {
    Reduce { state, action in ... }
}

I am trying to prevent a network request from being made if the child state has not changed, but I am unsure of how to handle the scenario where the user changes some properties and then reverts them back. I considered implementing a reducer to hold the initial state and a flag shouldSendRequest that is set to true and used to control the display of the send button in the UI, but I am not sure if this is the best approach.

So I came up with the following:

extension ReducerProtocol {
  @inlinable
  public func takeSnapshot<ChildState: Equatable>(
    on onAction: CasePath<Action, ()>,
    of toLocalState: @escaping (State) -> ChildState,
    flag keyPath: WritableKeyPath<State, Bool>
  ) -> some ReducerProtocol<State, Action> {
    Snapshot(base: self, onAction: onAction, toLocalState: toLocalState, flag: keyPath)
  }
}

public var snapshot: Any?

public struct Snapshot<Base: ReducerProtocol, ChildState: Equatable>: ReducerProtocol {
  @usableFromInline
  let base: Base

  @usableFromInline
  let toLocalState: (Base.State) -> ChildState

  @usableFromInline
  let onAction: CasePath<Base.Action, ()>

  @usableFromInline
  let flag: WritableKeyPath<Base.State, Bool>

  public init(
    base: Base,
    onAction: CasePath<Base.Action, ()>,
    toLocalState: @escaping (Base.State) -> ChildState,
    flag: WritableKeyPath<Base.State, Bool>
  ) {
    self.base = base
    self.onAction = onAction
    self.toLocalState = toLocalState
    self.flag = flag
  }

  @inlinable
  public func reduce(into state: inout Base.State, action: Base.Action) -> Effect<Base.Action, Never> {

    if let snapshot = (snapshot as? ChildState) { // we made snapshot
      let current = self.toLocalState(state)
      if current == snapshot {
        state[keyPath: self.flag] = false
      } else {
        state[keyPath: self.flag] = true
      }
    }
    guard self.onAction.extract(from: action) != nil
    else { return self.base.reduce(into: &state, action: action) }

    let previousLocalState = self.toLocalState(state)
    snapshot = previousLocalState

    let effects = self.base.reduce(into: &state, action: action)
    return effects
  }
}

usage in childReducer:
 var body: some ReduceProtocol<State, Action> {
    Reduce { state, action in ... }
    .takeSnapshot(on: /ChildReducer.Action.onAppear, to: { $0 }, flag: \.shouldSendRequest)
}

I am concerned that my current approach of using a reducer to store the initial state and a flag shouldSendRequest to control the display of the send button may not be the best solution because it is not generalizable and requires me to set/get a global variable. Additionally, I would need to implement the == operator to skip checking shouldSendRequest.

Any better alternative?

1. such as using a class instead of a struct for the reducer?
2. storing the child state in a client dependency and comparing it when the sendButtonTapped is triggered?
3. creating a StateWrapper struct that holds the initial state and compares it internally struct StateWrapper<T> { initial, current }

Do you have any recommendations or suggestions for these alternatives?

[Alex293]

If you use the @dependency system you could override the child env and guard if there is changes made before calling the networking dependency.

[ibrahimkteish]

Can you provide further explanation on what you meant in your response
do you mean something like the following ?

.ifLet(\.childState, action: /Action.childAction) {
      ChildReducer()
        .transformDependency(\.something) { $0.override(...) }
    }

[Alex293]

Yes that’s what I meant sorry it wasn’t very clear. I’m pretty sure someone posted a way to get the state there. Then you could put this logic in the transform dependency.

If you are not confortable about doing this here, you can go for some delegate action and move the logic and call to the parent.

[ibrahimkteish]

@tgrapperon do you have any suggestion ?

[tgrapperon]

Hey @ibrahimkteish! I'm trying to wrap my head around your use case. I wrote a relatively lengthly response, but I found out that I could read your case in two or three different ways that would lead to different answers.
Are prop1 and prop2 from the parent unrelated to the ones from the child?
Are your changes debounced?
Do you want to emit a request because the state has changed, or simply disallow requests when it hasn't. In this case, I guess that the reference is the last state used for the last request, right?
So, as I'm reading it, you want the boolean to act as a barrier gate to your requests rather than as a signal, and you want to keep track of the last state used when a request is performed. Right?

In any case, I don't know if the situation requires a generalized approach, and it is possible that an ad-hoc solution would be easier to implement (you can probably use a protocol if you want to share the behavior across other reducers). The "snapshot" state should however be saved in ChildReducer.State. Using a global variable like that will very likely have unexpected side effects as you mentioned. If you store the snapshot in State, the flag can be a computed property that checks if the snapshot is the same as the current value. And when you perform the request, you update the reference snapshot with the current values. But I may read your problem wrong, so feel free to correct me if I'm missing something.

[tgrapperon]

Or maybe prop1 and prop2 are shared, and you show the child, send a request, dismiss the child, work in parent, show the child again, but you don't want requests to be sent if the state is the same as the last time your child did send a request. It is very late now, but I'll try to respond in a few hours. This is a little trickier, as you have to keep a snapshot of the previous child data into the parent while the child state is nil. You can then inject the boolean into the child when your present it (when you create its state).

[ibrahimkteish]

Are prop1 and prop2 from the parent unrelated to the ones from the child?

true

Are your changes debounced?

no

Do you want to emit a request because the state has changed, or simply disallow requests when it hasn't. In this case, I guess that the reference is the last state used for the last request, right?

simply disallow

So, as I'm reading it, you want the boolean to act as a barrier gate to your requests rather than as a signal, and you want to keep track of the last state used when a request is performed. Right?

right, It doesn't matter for me as long as I don't end up doing a request with the same childState value, Imagine I setup the childState(prop1Value, prop2Value, false) as long as the values are the same I want to disable sending the request. it is like in sign up views when you put a weak password then the sign up button gets disabled, but for me as long as the child state remain the same.

example:

t0: prop1Value = "123" -> button disabled (initial childstate)
t1: prop1Value = "1234" -> button enabled childState != initial childState
t2: prop1Value = "123" -> button disabled childState == initial childstate

[tgrapperon]

So as I understand it, a computed property would work. What if you define you ChildReducer.State like this?

struct State { // ChildReducer.State
  var prop1: P1
  var prop2: P2
  let requestProp1: P1
  let requestProp2: P2

  init(prop1: P1, prop2: P2) {
    self.prop1 = prop1
    self.prop2 = prop2
    self.requestProp1 = prop1
    self.requestProp2 = prop2
  }

  var shouldSendRequest: Bool {
    prop1 != requestProp1 || prop2 != requestProp2
  }
}

Would it behave like you would expect? Is is possible to define ChildReducer.State like this in your case?
Otherwise, you can imagine wrapping this feature into another one that performs the validation and inject shouldSendRequest itself.

struct ConditionedChildReducer {
  struct State {
    var child: ChildReducer.State
    let referenceProp1: P1
    let referenceProp2: P2
    init(child: ChildReducer.State) {
      self.child = child
      self.referenceProp1 = child.prop1
      self.referenceProp2 = child.prop2
    }
  }

  enum Action {
    case child(ChildReducer.State)
  }

  var body: some ReducerProtocolOf<Self> {
    Reduce { state, action in
      switch action {
        case .child:
        state.child.shouldSendRequest = (state.child.prop1 != state.requestProp1) 
                                     || (state.child.prop2 != state.requestProp2)
        return .none
      }
    }
    Scope(state: \.child, action: /Action.child) {
      ChildReducer()
    }
  }
}

And in ParentReducer:

struct State {
  var child: ConditionedChildReducer.State?
}
enum Action {
  case child(ConditionedChildReducer.Action)
}

var body: some ReducerProtocolOf<Self> {
  Reduce {}
    .ifLet(\.child, action: /Action.child) {
      ConditionedChildReducer()
    }
}

Of course, you can probably imagine generalizations. For example, if we define the property wrapper

@propertyWrapper
public struct Snapshot<Value: Equatable> {
  var snapshot: Value?
  public var wrappedValue: Value? {
    didSet {
      if let wrappedValue {
        if snapshot == nil {
          self.snapshot = wrappedValue 
        }
      } else {
        self.snapshot = nil
      }
    }
  }
  public var projectedValue: Value? {
    self.snapshot
  }
  public init(wrappedValue: Value?) {
    self.wrappedValue = wrappedValue
    if let wrappedValue { self.snapshot = wrappedValue }
  }
}

Then, in the parent:

struct State {
  @Snapshot var child: Child?
  …
}

var body: some ReducerProtocolOf<Self> {
  Reduce { state, action in
	guard case .child = action else { return .none }
    let snapshot = state.$child
    let child = state.child
    state.child.shouldSendRequest = (child.prop1 != snapshot.prop1) 
                                 || (child.prop2 != snapshot.prop2)
    return .none
  }
  Reduce { state, action in
    // main parent reducer
  }
  .ifLet(\.child, action: /Action.child) {
    ChildReducer()
  }
}

Like this, the first Reduce will always run before ChildReducer. If we were able to store the reference values in ChildReducer, a similar Reduce could be installed above ChildReducer in the .ifLet block.
You can also imagine defining a modifier on top of that like you did. AFAIK, everything here should work. Let me know if it isn't.

[ibrahimkteish]

ok, thank you for you answer will try to sort this out asap.