Clojure状态保存疑问：函数式编程无变量时的API状态维持

Hey there! I totally get where you're coming from—making the jump to functional programming after years of imperative code feels like learning to ride a bike all over again, especially when it comes to ditching mutable variables. Let's break this down with your API example of adding people to a list, since that's a super relatable use case.

First off, let's clear up a common misconception: functional programming doesn't ban variables entirely—it bans mutable variables (where you modify the value a variable points to in-place). You can still use variables to hold references to immutable data, and there are plenty of idiomatic ways to manage state between requests without resorting to imperative variable reassignments.

Here are some practical approaches tailored to your API scenario:

1. Use Closures to Encapsulate Immutable State Updates #

Closures let you wrap state in a private scope, exposing only pure functions to interact with it. Instead of modifying the state directly, you create a new version of the state each time and update the closure's internal reference to it.

Example in JavaScript:

function createPersonStore() {
  // Private state—only accessible via the returned methods
  let people = [];

  return {
    // Pure function: takes input, returns new state, no side effects outside the closure
    addPerson: (newPerson) => {
      people = [...people, newPerson]; // Replace with new array (immutable update)
      return [...people]; // Return a copy to prevent external mutation
    },
    getPeople: () => [...people] // Return a copy for safety
  };
}

// Initialize the store once when your API starts
const personStore = createPersonStore();

// In your API endpoint handler
function handleAddPersonRequest(newPerson) {
  const updatedPeople = personStore.addPerson(newPerson);
  return { status: "success", data: updatedPeople };
}

Here, the people variable is never modified in-place—we always create a new array with the added person. The closure ensures the state is encapsulated, so external code can't mess with it directly.

2. Leverage Persistent Data Structures #

Persistent data structures are designed so that any modification creates a new version of the structure while reusing most of the old one (making it efficient). This lets you manage state by passing around these immutable structures instead of modifying variables.

You can use libraries like Immer (for JS) or built-in structures in languages like Scala/Clojure. Example with Immer:

import { produce } from "immer";

// Initial state—just a reference to an immutable array
let currentPeople = [];

// Pure reducer function: takes old state and input, returns new state
const addPersonReducer = (currentState, newPerson) => {
  // Immer lets you write "mutating" code, but it actually creates a new immutable structure
  return produce(currentState, draft => {
    draft.push(newPerson);
  });
};

// In your API handler
function handleAddPerson(newPerson) {
  // Update the reference to point to the new immutable state
  currentPeople = addPersonReducer(currentPeople, newPerson);
  return { status: "ok", people: currentPeople };
}

The key here is that currentPeople is just a pointer to the latest immutable state—we never change the original array, just replace which array the variable points to.

3. Dependency Injection: Pass State as a Parameter #

For a more explicit approach, treat state as an input to your pure functions. The API framework or your application's top-level code will manage the current state, passing it to your handler functions and storing the returned new state.

Example in Python:

# Pure function—no external dependencies, takes state and input, returns new state
def add_person(current_people, new_person):
    # Return a new list instead of modifying the original
    return current_people + [new_person]

# Top-level state management (initialized once)
current_people = []

# API endpoint handler
def handle_add_person_request(request):
    global current_people
    new_person = parse_request_body(request)
    # Update state with the result of the pure function
    current_people = add_person(current_people, new_person)
    return {"status": "success", "people": current_people}

This keeps your core logic (adding a person) completely pure and testable—you can test add_person without any external state.

4. Use a Functional State Management Library #

For larger applications, libraries like Redux (JS), ZIO (Scala), or Elm's Architecture handle state management in a functional way. All state updates go through pure reducer functions, and the state itself is immutable. These libraries take care of the boilerplate of tracking state changes between requests or UI interactions.

A Quick Recap #

The core idea is that state changes should produce new values, not modify existing ones. Variables are okay as long as they're just holding references to these immutable values—you're not changing the data itself, just pointing to the latest version. This makes your code easier to test, debug, and reason about, since every function's output depends only on its inputs.

内容的提问来源于stack exchange，提问作者Max Forasteiro