Scheme/Racket中set!的替代方案：禁用set!时如何实现递增函数

Great question! Since Scheme and Racket are built around functional programming principles, ditching set! means leaning into pure, immutable approaches—no mutable state required. Let’s walk through practical alternatives and how to refactor your increment-based functions.

1. Use Tail Recursion (The Functional "Loop" Replacement) #

Instead of mutating a variable with set! to track increments, pass the current state as a parameter to a helper function. Tail recursion is efficient (Racket optimizes it to avoid stack overflow) and keeps everything pure.

Example: Counting List Elements #

Suppose you originally wrote this with set!:

(define (count-elements lst)
  (let ([count 0])
    (for-each (lambda (x) (set! count (+ count 1))) lst)
    count))

Refactor it to use tail recursion:

(define (count-elements lst)
  ; Helper function carries the current count as a parameter
  (define (count-helper remaining current-count)
    (if (empty? remaining)
        current-count  ; Base case: return the final count
        (count-helper (rest remaining) (+ current-count 1))))  ; Increment via parameter
  (count-helper lst 0))  ; Start with initial count 0

Here, we never modify a variable—each recursive call creates a new value for current-count instead of updating an existing one.

2. Leverage Higher-Order Functions #

Racket has built-in higher-order functions like foldl and foldr that handle iteration and accumulation for you. These are perfect for replacing set!-based increment logic.

Example: Same Counting Function with foldl #

(define (count-elements lst)
  ; foldl takes a function, initial accumulator, and list
  (foldl (lambda (element accumulator) (+ accumulator 1)) 0 lst))

The foldl function iterates over the list, applying the lambda to each element and the current accumulator. We start with 0, and each step increments the accumulator—no mutable state needed.

3. Pure Functional State Encapsulation (For "Persistent" Counters) #

If you need something like a reusable counter that remembers its last value, you can avoid set! by returning new counter functions along with each incremented value. This is called "persistent state"—each update creates a new version of the state instead of modifying the old one.

Example: Pure Functional Counter #

Original set! version:

(define make-counter
  (lambda ()
    (let ([current 0])
      (lambda ()
        (set! current (+ current 1))
        current))))

Refactored pure version:

(define make-counter
  (lambda (current-value)
    (lambda ()
      ; Return a pair: (new-value . new-counter-function)
      (cons (+ current-value 1) (make-counter (+ current-value 1))))))

; How to use it:
(define initial-counter (make-counter 0))
(define first-increment (initial-counter))
; first-increment is (1 . #<procedure>)
(define second-increment ((cdr first-increment)))
; second-increment is (2 . #<procedure>)

Each call to the counter gives you the new value and a fresh counter that starts from that value. No variables are mutated—everything is immutable.

Key Takeaway #

The core idea in functional programming is to pass state as parameters and generate new values instead of modifying existing ones. set! is for mutable state, but in most cases, you can replace it with recursion, higher-order functions, or persistent state patterns that keep your code pure and aligned with Scheme/Racket’s design.

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