Reducer<State, Action, Environment> class final

A pure function that processes an action against the current state and returns the new state along with any Effects to execute.

Reducers are the heart of the Composable Architecture. They are pure, deterministic, and composable. A reducer never performs side effects directly; instead, it returns Effect values that describe the work to be done.

Creating Reducers

// State-only transformation (no effects)
final counterReducer = Reducer<int, CounterAction, EmptyEnvironment>.transform(
  (state, action, env) => switch (action) {
    CounterAction.increment => state + 1,
    CounterAction.decrement => state - 1,
  },
);

// Full reducer with effects
final userReducer = Reducer<UserState, UserAction, UserEnv>(
  reduce: (state, action, env) => switch (action) {
    LoadUser() => (
      state: state.copyWith(isLoading: true),
      effect: Effect.task(() => env.api.fetchUser())
        .map((user) => UserAction.loaded(user)),
    ),
    UserLoaded(:final user) => (
      state: state.copyWith(user: user, isLoading: false),
      effect: Effect.none(),
    ),
  },
);

Composition

Reducers compose via combine, pullback, forEach, and ifLet:

final appReducer = Reducer.combine([
  counterReducer.pullback(stateLens: ..., actionLens: ...),
  userReducer.pullback(stateLens: ..., actionLens: ...),
]);