在Scheme中存储返回值：如何反转odds函数的返回结果

Hey there! Let's work through this problem together. First, your existing odds function correctly extracts the odd-positioned elements of a list—great work on that foundation. Let's tackle how to reverse its output, plus clear up the confusion around lambdas, set-cons!, and let in recursion.

1. The Simplest Fix: Combine reverse with Your Existing odds Function #

You don't need to modify your original odds function at all! Since it returns a standard list, you can just wrap its call with Scheme's built-in reverse function directly:

; Your original odds function
(define (odds lst)
  (if (null? lst)
      lst
      (cons (car lst)
            (if (or (null? lst) (not (pair? (cdr lst))))
                '()
                (odds (cddr lst))))))

; Reverse the result of odds
(reverse (odds '(1 2 3 4 5))) ; Returns (5 3 1)
(reverse (odds '(a b c d e f))) ; Returns (e c a)

This is the most straightforward approach because it leverages existing pure functions without introducing mutable state or complex logic.

2. Build the Reversed List Directly (Tail-Recursive Version) #

If you want the odds function to return a reversed list right away, you can rewrite it with a helper function that uses an accumulator. This is also tail-recursive, which is more efficient for large lists:

(define (odds-reversed lst)
  ; Helper function with an accumulator to build the reversed list
  (define (helper remaining acc)
    (if (null? remaining)
        acc ; Return the accumulated reversed list when done
        (helper (cddr remaining) ; Move to the next odd-positioned element
                (cons (car remaining) acc)))) ; Prepend current element to accumulator
  (helper lst '())) ; Start with empty accumulator

(odds-reversed '(1 2 3 4 5)) ; Returns (5 3 1) immediately

The accumulator (acc) keeps track of the reversed list as we iterate. Each time we pick an odd-positioned element, we add it to the front of the accumulator—this naturally builds the list in reverse order without needing a separate reverse call.

3. Why Your Previous Attempts Didn't Work #

Let's break down the issues you ran into:

• Lambda storage: If you tried using a lambda to capture the result, you might have forgotten to invoke the lambda or properly pass the recursive output. Lambdas are functions, so you need to call them with the right arguments to get a value. For example, wrapping odds in a lambda like (lambda (lst) (reverse (odds lst))) works, but you have to call that lambda with your list: ((lambda (lst) (reverse (odds lst))) '(1 2 3)).
• set-cons!: This function modifies the cdr of an existing cons cell, which is a mutable operation. In pure functional recursion (like your original odds), mutable state is unnecessary and can lead to bugs if you're not careful. Scheme encourages building new lists instead of modifying existing ones.

4. Using let in Recursive Functions #

let is used to bind temporary variables in a local scope, which can make your recursive code cleaner and avoid redundant computations. For example, you can use let in your original odds function to avoid calculating (cdr lst) multiple times:

(define (odds lst)
  (if (null? lst)
      lst
      (let ((next (cdr lst))) ; Bind (cdr lst) to a local variable 'next'
        (cons (car lst)
              (if (or (null? next) (not (pair? next)))
                  '()
                  (odds (cdr next))))))) ; Use 'next' instead of recalculating (cdr lst)

Here, let creates a local variable next that holds the rest of the list after the first element. This makes the code easier to read and avoids redundant calls to cdr.

If you wanted to use let with the reversed version, you could bind the updated accumulator, but the helper function approach is still more intuitive for this use case.

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