Here’s an example from this post:

export default handleActions (
  {
    ADD_TODO: (state, action) => {
      return {
        ...state,
        currentTodo: '',
        todos: state.todos.concat (action.payload),
      };
    },
    LOAD_TODOS: (state, action) => {
      return {
        ...state,
        todos: action.payload,
      };
    },
    UPDATE_CURRENT: (state, action) => {
      return {
        ...state,
        currentTodo: action.payload,
      };
    },
    REPLACE_TODO: (state, action) => {
      return {
        ...state,
        todos: state.todos.map (
          t => (t.id === action.payload.id ? action.payload : t)
        ),
      };
    },
    REMOVE_TODO: (state, action) => {
      return {
        ...state,
        todos: state.todos.filter (t => t.id !== action.payload),
      };
    },
    [combineActions (SHOW_LOADER, HIDE_LOADER)]: (state, action) => {
      return {...state, isLoading: action.payload};
    },
  },
  initState
);

To me this and Redux in general both look like a half-baked reimplement of JavaScript’s class, except the method names are UPPER_CASE because they are “constant”, and state is managed elsewhere and passed as a parameter instead of being stored on this. Why reinvent this syntax? Is it just so we can be sure we’re using “functional programming” and have “no internal state”?

If you want to eliminate boilerplate, cut the knot. Let me write my reducer as a class, and then generate the action creators, action names, etc from the class’s declared methods. You can still have all the benifits of redux while using a pleasing syntax.

A sketch (pardon, on mobile):

class TodoReducer extents Reducer {
  static initialState = () => ({ ... })

  addTodo(state, todo) {
    return {
      ...state,
      currentTodo: '',
      todos: state.todos.concat(todo),
    }
  }

  // more methods ...
}

// each camel-case methodName has a constant case METHOD_NAME.
// Returns an object with each constant case method name mapped to itself. 
export const actions = TodoReducer.actions()

// creates an object mapping methodNames to functions that return an action object with type 
// set to the constant case name of that method
export const actionCreators = TodoReducer.actionCtreators

// creates a reducer function from the class that handles dispatching redux actions as regular method calls on an instance of the class.
// the wrapper function could also do hand-holding like assert there is no state being recorded in the instance
// or, a new instance could be created for each dispatch, although the perf would suck
export const reducer = TodoReducer.reducer()