Ao ler "The Seasoned Schemer", comecei a aprender sobreletrec. Entendo o que ele faz (pode ser duplicado com um Y-Combinator), mas o livro está usando-o em vez de recorrente nodefineFunção d que opera em argumentos que permanecem estáticos.

Um exemplo de uma função antiga usando odefinefunção d recorrente em si mesma (nada de especial):

(define (substitute new old l)
  (cond
    ((null? l) '())
    ((eq? (car l) old)
      (cons new (substitute new old (cdr l))))
    (else
      (cons (car l) (substitute new old (cdr l))))))

Agora, para um exemplo dessa mesma função, mas usandoletrec:

(define (substitute new old l)
  (letrec
    ((replace
      (lambda (l)
        (cond
          ((null? l) '())
          ((eq? (car l) old)
           (cons new (replace (cdr l))))
          (else
           (cons (car l) (replace (cdr l))))))))
(replace lat)))

Além de ser um pouco mais longo e mais difícil de ler, não sei por que eles estão reescrevendo funções no livro para usar o letrec. Existe um aprimoramento de velocidade quando recorrente sobre uma variável estática dessa maneira, porque você não passa adiante?

Essa prática padrão é para funções com argumentos que permanecem estáticos, mas um argumento que é reduzido (como os elementos recorrentes de uma lista)?

Algumas contribuições de Schemers / LISPers mais experientes ajudariam!