When do we use Reducers/Plain Old Structs

[georgemp]

I'm trying to figure out where to draw the line between using a regular struct as part of my view model vs using a reducer. A semi-contrived example follows.

Let's say we have a tagged string representing a line of text and a tagged int to represent the column in the string (column doesn't start at 0, but at 1).

enum ColumnTag {}
typealias TextColumn = Tagged<ColumnTag, Int>

enum LineTag {}
typealias Line = Tagged<LineTag, Int>

extension Line {
   var range: Range<TextColumn> {
      TextColumn(1)..<TextColumn(self.rawValue.utf8.count + 1)
   }

   func replaceSubrange(subrange: Range<TextColumn>, with str: String) {
      // TODO
   }

   func popLast() -> Char? {
      self.rawValue.popLast()
   }

   subscript(bound: Range<TextColumn> -> Substring {
      // TODO
   }
}

Since, we are defining our Ranges on TextColumn, we might want to support other RangeExpression's like PartialRangeFrom, PartialRangeUpTo etc.

extension PartialRangeFrom<TextColumn> {
   func relative(to line: Line) -> Range<TextColumn> {
      self.lowerBound..<line.range.upperBound
   }
}

This works great. But, there are some complicated checks and balances in the mutating methods on Line. So, I was wondering if I could build it with a Reducer (just so as to have guaranteed unit testing across state changes). There are a couple of issues that I have come across in this attempt

1. A method like popLast() mutates Line and also returns a value. This seems to require me to have two Actions - popLast and then a transition to poppedLast(Char?). When I want to pop the last char, I'd send a action message popLast and then send an effect poppedLast(Char?).. Seems convoluted and less than ideal.
2. The reducer doesn't have access to the actual State data structure. Only the store seems to have it. So, if Line were to be implemented as a reducer, I'd have to implement my PartialRangeFrom on Store<Line.State, Line.Action>.
3. Errors in any of mutation methods would have to be reported as an additional action/effect.

protocol CharacterSequence : Sequence where Element == Character {}

@Reducer
struct TextLine {
    @ObservableState
    struct State: Equatable {
        var content: String
    }

    enum Action {
        case append(StringLike)
        case popLast
        case poppedLast(Character?)

        enum StringLike {
            case string(String)
            case character(Character)
            case substring(Substring)
            case sequence(any CharacterSequence)
        }
    }

   /*
   var range: Range<TextColumn> {
     // Cannot implement here as we don't have access to state.content
   }
  */

    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case let .append(appendable):
                switch appendable {
                case let .string(str):
                    state.content.append(str)
                case let .character(char):
                    state.content.append(char)
                case let .substring(substr):
                    state.content.append(contentsOf: substr)
                case let .sequence(seq):
                    state.content.append(contentsOf: seq)
                }
                return .none
            case .popLast:
                return .send(.poppedLast(state.content.popLast()))
            case let .poppedLast(char):
                return .none
            }
        }
    }
}

extenstion Store<Line.State, Line.Action> {
   var range: Range<TextColumn> {
     TextColumn(1)..<TextColumn(self.state.utf8.count + 1)
   }
}

extension PartialRangeFrom<Store<Line.State, Line.Action>> {
   func relative(to store: Store<Line.State, Line.Action) -> Range<TextColumn> {
      self.lowerBound..<store.range.upperBound
   }
}

Applying these methods to Store instead of Line seems to be sub-optimal. Perhaps, it's ok since the Reducer will always be used in conjunction with the Store?

Is there a better way to approach this using Reducer's or am I better off just using a plain old struct?

[mbrandonw]

Hi @georgemp, I believe this problem is best left to a plain struct with some methods/functions defined on it. And it is still completely testable as a standalone type.

It is best to leave reducers to full features of your app where actions correspond to things the user did in the UI.