[TCA] Sharing logic with actions

액션을 사용하여 리듀서의 여러 부분에서 로직을 공유하는 일반적인 패턴이 있는데, 이는 비효율적인 패턴이다.

 

액션을 전송하는 것은 클래스에서 메서드를 호출하는 것만큼 가벼운 작업이 아니기 때문이다. 액션은 애플리케이션의 여러 레이어를 통과하며 각 레이어마다 리듀서가 액션을 가로채고 재해석할 수 있다.

대신, Reducer를 준수하면서 간단한 메서드를 사용하여 로직을 공유하는 것이 훨씬 더 좋은 방법이다. 이 메서드는 변이를 해야할 경우, State를 inout 인자로 받아서 사용할 수 있고, Effect<Action>을 반환할 수 있다. 이를 통해 불필요한 액션을 전송하는 비용을 발생시키지 않고 로직을 공유할 수 있다.

 

예를 들어, 피쳐에 3개의 UI 컴포넌트가 있고 어떤 컴포넌트가 변경되면 해당 상태 필드를 업데이트하고, 변이를 수행하여 이펙트를 실행하려고 한다고 가정해보자. 이러한 공통된 변이와 이펙트를 별도의 액션으로 정의하고 각 사용자 액션은 해당 공유 액션을 즉시 실행하는 이펙트를 반환할 수 있다.

struct Feature: Reducer {
  struct State {
    // ...
  }
  enum Action {
    // ...
  }

  func reduce(into state: inout State, action: Action) -> Effect<Action> {
    switch action {
    case .buttonTapped:
      state.count += 1
      return .send(.sharedComputation)

    case .toggleChanged:
      state.isEnabled.toggle()
      return .send(.sharedComputation)

    case let .textFieldChanged(text):
      state.description = text
      return .send(.sharedComputation)

    case .sharedComputation:
      // Some shared work to compute something.
      return .run { send in
        // A shared effect to compute something
      }
    }
  }
}

이는 로직과 이펙트를 공유하는 방법이지만, 사용자가 하나의 액션을 수행했음에도 불구하고 2개의 액션에 대한 비용이 발생하고 있으므로 비효율적이다.

이러한 성능 문제 외에도 이 패턴을 따르지 않아야 하는 2가지 이유가 있다.

 

첫째, 이런 형식의 로직 공유 방식은 유연성이 부족하다. 공유 로직이 별도의 액션으로 분리되기 때문에 항상 초기 로직 이후에 실행되어야 한다. 하지만 초기 로직 실행 전에 일부 공유 로직을 실행해야 할 경우 어떻게 해야할까? 이런 경우에는 이 패턴을 적용하기 어렵다.

둘째, 이런 형식의 로직 공유 방식은 테스트를 어렵게 만든다. 사용자 액션을 전송할 때 공유 액션을 수신하고 상태 변경을 확인해야 한다. 이렇게 하면 테스트가 불필요한 내부 세부사항으로 팽창되고, 테스트가 사용자가 기능을 어떻게 사용하는지에 대한 명확한 스크립트로 읽히지 않게 된다.

let store = TestStore(initialState: Feature.State()) {
  Feature()
}

store.send(.buttonTapped) {
  $0.count = 1
}
store.receive(.sharedComputation) {
  // Assert on shared logic
}
store.send(.toggleChanged) {
  $0.isEnabled = true
}
store.receive(.sharedComputation) {
  // Assert on shared logic
}
store.send(.textFieldChanged("Hello") {
  $0.description = "Hello"
}
store.receive(.sharedComputation) {
  // Assert on shared logic
}

따라서 리듀서 내에서 전용 액션을 사용하여 동기적 이펙트를 실행하는 방식으로 로직을 공유하는 패턴은 추천하지 않는다.

 

대신, 피쳐의 리듀서에 정의된 메서드로 로직을 공유하는 것을 추천한다. 이 메서드는 모든 종속성에 대한 전체 액세스 권한을 갖고, 상태를 변경해야 하는 경우 inout State를 취하고, 이펙트를 실행해야 할 경우 Effect<Action>을 반환할 수 있다.

위의 예제는 다음과 같이 리팩터링할 수 있다.

struct Feature: Reducer {
  struct State {
    // ...
  }
  enum Action {
    // ...
  }

  func reduce(into state: inout State, action: Action) -> Effect<Action> {
    switch action {
    case .buttonTapped:
      state.count += 1
      return self.sharedComputation(state: &state)

    case .toggleChanged:
      state.isEnabled.toggle()
      return self.sharedComputation(state: &state)

    case let .textFieldChanged(text):
      state.description = text
      return self.sharedComputation(state: &state)
    }
  }

  func sharedComputation(state: inout State) -> Effect<Action> {
    // Some shared work to compute something.
    return .run { send in
      // A shared effect to compute something
    }
  }
}

이 방식은 이전과 동일하게 동작하지만, 사용자 액션이 전송될 때 모든 로직이 추가적인 액션을 보내지 않고 한 번에 실행된다. 또한 위에서 언급한 다른 문제들도 해결한다.

 

예를 들어 핵심 로직보다 공유 로직을 먼저 실행해야 하는 경우, 다음과 같이 실행할 수 있다.

case .buttonTapped:
  let sharedEffect = self.sharedComputation(state: &state)
  state.count += 1
  return sharedEffect

이런 식으로 공유 로직을 언제, 어떻게, 어디서 실행할지를 유연하게 결정할 수 있다.

 

또한 전송되는 공유 액션의 추가 내부 세항을 확인할 필요가 없으므로 테스트가 더 간단해진다. 테스트는 사용자가 기능에서 무엇을 수행하는지에 대한 스크립트처럼 읽히게 된다.

let store = TestStore(initialState: Feature.State()) {
  Feature()
}

store.send(.buttonTapped) {
  $0.count = 1
  // Assert on shared logic
}
store.send(.toggleChanged) {
  $0.isEnabled = true
  // Assert on shared logic
}
store.send(.textFieldChanged("Hello") {
  $0.description = "Hello"
  // Assert on shared logic
}

 

원문

https://pointfreeco.github.io/swift-composable-architecture/1.0.0/documentation/composablearchitecture/performance/#Sharing-logic-with-actions