An onChange(of:) reducer?

[notcome]

I am working on an app where I need to save data to disks whenever the user edits something. I ended up with a reducer that allows me to trigger an effect whenever the watched value changes, akin to SwiftUI's onChange(of:) modifier. Example use case:

Scope(\.document, action: Action.document) {
    Editor()
}.onChange(of: \.document) { oldValue, newValue in
    Action.save(newValue).throttle(...)
}

Later I found it to be more useful than I thought. For instance, I have been using it to watch my app state and update notifications and widgets. Questions:

1. Is this possible to achieve with whatever TCA's builtin functions, without writing one myself?
2. If not, are you people interested in integrating this into the library?

My sample implementation, hopefully it is bug-free:

@usableFromInline
struct _OnChangeOf<Value: Equatable, Child: ReducerProtocol>: ReducerProtocol {
    @usableFromInline
    typealias State = Child.State
    @usableFromInline
    typealias Action = Child.Action

    @usableFromInline
    let child: Child
    @usableFromInline
    let getValue: (State) -> Value
    @usableFromInline
    let onChange: (Value, Value) -> Effect<Action, Never>

    @inlinable
    init(
        child: Child,
        getValue: @escaping (State) -> Value,
        onChange: @escaping (Value, Value) -> Effect<Action, Never>
    ) {
        self.child = child
        self.getValue = getValue
        self.onChange = onChange
    }

    @inlinable
    func reduce(into state: inout State, action: Action) -> Effect<Action, Never> {
        let oldValue = getValue(state)
        let effect = child.reduce(into: &state, action: action)
        let newValue = getValue(state)
        guard oldValue != newValue else { return effect }
        return onChange(oldValue, newValue).merge(with: effect)
    }
}

extension ReducerProtocol {
    @inlinable
    public func onChange<Value: Equatable>(
        of getValue: @escaping @Sendable (State) -> Value,
        perform action: @escaping @Sendable (Value, Value) -> Effect<Action, Never>
    ) -> some ReducerProtocol<State, Action>
    {
        _OnChangeOf(child: self, getValue: getValue, onChange: action)
    }
}

extension ReducerProtocol where State: Equatable {
    @inlinable
    public func onChange(
        perform action: @escaping @Sendable (State, State) -> Effect<Action, Never>
    ) -> some ReducerProtocol<State, Action>
    {
        onChange(of: { x in x }, perform: action)
    }
}

[GreatApe]

There is an onChange reducer in the IsoWords project, quite similar to this. Seems like a very useful concept!

[notcome]

Good to hear that. I was afraid that this might be viewed as anti-pattern 😂

[mbrandonw]

It's definitely powerful to use, and here's our stab at that operator from isowords: https://github.com/pointfreeco/isowords/blob/main/Sources/TcaHelpers/OnChange.swift

As you can see we have a few variations, and we haven't quite figured out the most ideal version of this operator, which is one of the reasons we have not added it to the library yet.