Reducers reutilizables: extraer una ley y parametrizarla

Llega un momento en toda app madura en el que tres features hacen lo mismo con nombres distintos: buscar con retardo y descartar respuestas obsoletas, paginar una lista, validar un formulario, registrar cada acción para analítica. En una arquitectura orientada a objetos esa repetición se ataca con una clase base, un protocolo con extensión o un servicio compartido, y las tres opciones tienen el mismo vicio: obligan al que reutiliza a conocer al que provee. En TCA la respuesta es de otra naturaleza, porque el reducer ya es un valor: extraes la ley común a un tipo propio, la parametrizas por lo que varía, y la enchufas donde haga falta con los mismos operadores que ya usas. Nada hereda de nada, y la pieza extraída sigue siendo un reducer corriente.

Dos formas de reutilizar

La distinción es limpia y conviene fijarla antes de escribir una línea. Un reducer hoja genérico encapsula un dominio completo —su propio State, su propia Action— parametrizado por el tipo de dato con el que trabaja; se reutiliza incrustándolo en padres distintos con Scope, ifLet o forEach, y cada padre le presta una rebanada de su estado. Un reducer envoltorio genérico no tiene dominio propio: es genérico sobre otro reducer, al que envuelve para añadirle una preocupación transversal; se reutiliza como modificador encadenado con punto, exactamente como _printChanges o signpost.

La pregunta que las separa es una sola: ¿lo que se repite es un trozo de dominio o un trozo de comportamiento? Si lo repetido tiene estado propio que el padre no debería mirar, es una hoja. Si lo repetido es algo que le ocurre a cualquier estado —registrarlo, medirlo, restringirlo— es un envoltorio.

flowchart TD
R[repeticion detectada] --> Q{tiene estado propio}
Q -->|si| H[hoja generica sobre el dominio]
Q -->|no| W[envoltorio generico sobre otro reducer]
H --> S[se compone con Scope ifLet o forEach]
W --> M[se aplica como modificador encadenado]

La hoja genérica: una feature parametrizada por su dominio

Un buscador con retardo es el ejemplo canónico: la mecánica —escribir, esperar, cancelar la petición anterior, recibir— es idéntica para productos, para usuarios y para etiquetas; lo único que cambia es el tipo del resultado y la función que consulta. Eso se expresa con genéricos y con una closure inyectada en el inicializador.

@Reducer
struct Buscador<Elemento: Equatable & Identifiable & Sendable> {
  @ObservableState
  struct State: Equatable {
    var consulta = ""
    var resultados: IdentifiedArrayOf<Elemento> = []
    var cargando = false
  }

  enum Action: Equatable {
    case consultaCambiada(String)
    case respuesta([Elemento])
  }

  let buscar: @Sendable (String) async throws -> [Elemento]

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .consultaCambiada(texto):
        state.consulta = texto
        state.cargando = true
        return .run { envia in
          try await envia(.respuesta(try await buscar(texto)))
        }
        .debounce(id: CancelID.busqueda, for: .milliseconds(300), scheduler: DispatchQueue.main)
      case let .respuesta(items):
        state.cargando = false
        state.resultados = IdentifiedArray(uniqueElements: items)
        return .none
      }
    }
  }

  private enum CancelID { case busqueda }
}

En el padre, la instancia concreta se elige al componer, y dos buscadores de tipos distintos conviven sin rozarse:

var body: some ReducerOf<Self> {
  Scope(state: \.productos, action: \.productos) {
    Buscador<Producto>(buscar: { try await catalogo.buscar($0) })
  }
  Scope(state: \.usuarios, action: \.usuarios) {
    Buscador<Usuario>(buscar: { try await directorio.buscar($0) })
  }
  Reduce { state, action in ... }
}

Dos detalles no negociables. El primero es que la hoja no conoce a su padre: recibe la función de búsqueda por el inicializador —o la resuelve con @Dependency, que suele ser preferible— y si necesita avisar hacia arriba lo hace con un caso delegate en su Action que el padre escucha. El segundo es que el estado que le presta el padre debe ser suyo en exclusiva; en cuanto dos reducers compiten por escribir el mismo campo, la reutilización se convierte en acoplamiento.

El envoltorio genérico: conformar a Reducer a mano

Cuando lo repetido es comportamiento y no dominio, escribes un struct genérico sobre Base: Reducer que guarda al envuelto y conforma a Reducer implementando reduce directamente. Como implementas el método y no la propiedad, el tipo asociado Body se resuelve como Never y no hay body que escribir.

struct Auditada<Base: Reducer>: Reducer {
  let base: Base
  let registrar: @Sendable (Base.Action) -> Void

  init(
    registrar: @escaping @Sendable (Base.Action) -> Void,
    @ReducerBuilder<Base.State, Base.Action> base: () -> Base
  ) {
    self.registrar = registrar
    self.base = base()
  }

  func reduce(into state: inout Base.State, action: Base.Action) -> Effect<Base.Action> {
    registrar(action)
    return base.reduce(into: &state, action: action)
  }
}

extension Reducer {
  func auditada(_ registrar: @escaping @Sendable (Action) -> Void) -> Auditada<Self> {
    Auditada(registrar: registrar) { self }
  }
}

La pieza que hay que mirar dos veces es la anotación @ReducerBuilder<Base.State, Base.Action> sobre el parámetro del inicializador: es lo que permite que quien use tu tipo escriba varios reducers dentro de las llaves sin comas, igual que dentro de un Scope. Es literalmente el mismo mecanismo que emplea la biblioteca, disponible para ti sin ninguna API privada. Y la extensión de Reducer con un método que devuelve Auditada<Self> es lo que convierte tu tipo en un modificador encadenable, de modo que compone con los oficiales sin coordinación previa.

Cuándo no extraer

Toda abstracción cobra un peaje: un tipo genérico más que leer, parámetros que nombrar, mensajes de compilador más largos y una indirección que el siguiente lector tendrá que deshacer mentalmente. Extraer demasiado pronto produce el peor resultado posible, un reducer «reutilizable» con seis parámetros que solo se usa dos veces y que nadie se atreve a tocar.