Separar orígenes: view, _internal y delegate

Un enum Action plano funciona bien mientras la feature es pequeña, y deja de funcionar exactamente cuando más lo necesitas. A los treinta casos el switch mezcla el toque de un botón con la respuesta de una llamada de red y con un mensaje que en realidad iba dirigido al padre, y nada en el tipo distingue quién tenía derecho a enviar cada uno. La convención que Point-Free consolidó como práctica estándar consiste en partir la Action según dos preguntas que el nombre plano oculta: de dónde viene el suceso y para quién es. Las respuestas producen tres grupos —view, _internal y delegate— y esa partición convierte una lista amorfa en un contrato con tres cláusulas verificables.

Tres orígenes, tres audiencias

La partición no es decorativa: cada grupo obedece invariantes distintas sobre quién puede enviarlo y quién debe manejarlo.

La tercera fila es la que sorprende y la que más rinde: el reducer que emite una acción delegate no la maneja, y el que la maneja no la emite. Es la única categoría cuyo emisor y cuyo destinatario están en niveles distintos del árbol.

@Reducer
struct Editor {
  @ObservableState
  struct State: Equatable {
    var texto = ""
    var guardando = false
  }

  enum Action {
    case view(View)
    case _internal(Internal)
    case delegate(Delegate)

    enum View: Equatable {
      case alAparecer
      case textoEditado(String)
      case guardarPulsado
    }
    enum Internal: Equatable {
      case guardadoTerminado(Bool)
      case borradorRecuperado(String)
    }
    enum Delegate: Equatable {
      case documentoGuardado(Documento.ID)
      case edicionCancelada
    }
  }
}

flowchart TD
V[Vista] --> AV[Action view]
AV --> R[Reducer de la feature]
R --> EF[Effect]
EF --> AI[Action _internal]
AI --> R
R --> AD[Action delegate]
AD --> P[Reducer padre]
style AV fill:#a6e3a1,color:#11111b
style AI fill:#f9e2af,color:#11111b
style AD fill:#f38ba8,color:#11111b

view: la única puerta abierta hacia dentro

Agrupar bajo view los sucesos originados en la interfaz cumple dos funciones. La primera es documental: leer ese subenum equivale a leer el inventario completo de gestos que la pantalla admite, sin ruido de infraestructura. La segunda es defensiva: al declarar el grupo se hace evidente que ningún otro emisor debería usarlo, y en la lección siguiente sobre ViewAction verás cómo esa convención social se convierte en una restricción que el compilador impone.

Reduce { state, action in
  switch action {
  case .view(.alAparecer):
    return .run { send in
      await send(._internal(.borradorRecuperado(borradores.leer())))
    }
  case let .view(.textoEditado(nuevo)):
    state.texto = nuevo
    return .none
  case .view(.guardarPulsado):
    state.guardando = true
    return .run { [texto = state.texto] send in
      await send(._internal(.guardadoTerminado(api.guardar(texto))))
    }
  // ...
  }
}

Fíjate en la simetría del flujo: una acción view entra, el reducer devuelve un efecto, y ese efecto solo puede regresar como acción _internal. La vista nunca produce una _internal y el efecto nunca produce una view; cada carril tiene un único sentido.

_internal: sucesos que solo el reducer puede provocar

El grupo _internal recoge lo que ocurre por debajo de la interfaz: la respuesta de una petición, el disparo de un temporizador, la llegada de un elemento de un stream. El guion bajo inicial no tiene significado para el compilador; es una señal convencional, tomada de la costumbre de Swift para lo semiprivado, que declara que ese subenum es asunto interno de la feature y que ningún emisor externo debería construirlo.

Esta separación paga dividendos inmediatos en testing. Un test que envía .view(.guardarPulsado) y afirma que recibe ._internal(.guardadoTerminado(true)) distingue con claridad la causa —un gesto— del efecto —una respuesta del sistema—, mientras que en un enum plano ambas cosas se ven idénticas y la lectura del test no revela la dirección del flujo.

delegate: hablar hacia arriba sin mirar hacia arriba

El grupo delegate resuelve el problema más delicado de la composición: cómo comunica un hijo un desenlace relevante al padre sin adquirir ninguna referencia hacia él. La respuesta de TCA es que el hijo emite un hecho dirigido a nadie en particular, y el padre, que ya enruta las acciones del hijo, lo intercepta.

// En el hijo: emitir, nunca manejar
case ._internal(.guardadoTerminado(true)):
  state.guardando = false
  return .send(.delegate(.documentoGuardado(state.id)))

case .delegate:
  return .none   // el hijo jamás reacciona a sus propias delegate

// En el padre: manejar, nunca emitir
Scope(state: \.editor, action: \.editor) { Editor() }
Reduce { state, action in
  switch action {
  case let .editor(.delegate(.documentoGuardado(id))):
    state.recientes.insert(id, at: 0)
    state.editor = nil
    return .none
  default:
    return .none
  }
}

La invariante es rígida y conviene enunciarla como norma: el hijo emite acciones delegate y devuelve .none para ellas; el padre las maneja y nunca las envía. Cumplirla mantiene la propiedad Lego intacta, porque Editor sigue compilando y corriendo aislado en una preview aunque nadie escuche sus delegaciones. Romperla —dejar que el hijo mute su propio estado al manejar una delegate— crea un canal de doble sentido que reintroduce el acoplamiento que la partición venía a eliminar.