Scheme/DrRacket, vermeiden let verwenden, noch nicht gleiche Funktion zweimal

Question

Auswertung habe ich eine Zuordnung Codierung Klasse ich bin zu lösen nicht in der Lage :(

(define f 
    (lambda (x) 
    (i (g x) (h (g x))))) 

i, g und h sind nur willkürliche Funktionsnamen. Dies ist der Code und ich muss ihn so umschreiben, dass (g x) nur einmal ausgewertet wird, aber ohne Verwendung (oder irgendeine Variante davon), die nur und lambda als vordefinierte Funktionen verwenden. Ich bin auch nicht berechtigt, Berechnungen aus f zu nehmen, das heißt, alle Berechnungen müssen innerhalb dieser Funktion erfolgen.

Answer 1

Der einfache Weg ist

(define f 
    (lambda (x) 
    (define intermediary (g x)) 
    (i intermediary (h intermediary)))) 

und desto komplizierter

(define f 
    (lambda (x) 
    ((lambda (intermediary) ; anonymous procedure 
     (i intermediary (h intermediary))) 
    (g x)))) 

oder Vermeidung des anonymen Verfahren sein würde und er den Namen Unter geben:

(define f 
    (lambda (x) 
    (define sub 
     (lambda (intermediary) 
     (i intermediary (h intermediary)))) 
    (sub (g x)))) 

Answer 2

Lustig, wie Sie dürfen keine Varianten von let verwenden während und lambda erlaubt ist, die Ich würde sicherlich sagen, dass wahre Varianten von let (oder umgekehrt) sind.

(let ((v1 expr1) ...) 
    body ...) 

ist die gleiche wie

((lambda (v1 ...) 
    body ...) expr1 ...) 

So ist let eine Variante des lambda .. Also:

(define f 
    (lambda (x) 
    (let ((gx (g x))) 
     (i gx (h gx))))) 

Can natürlich neu geschrieben werden:

(define f 
    (lambda (x) 
    ((lambda (gx) 
     (i gx (h gx))) 
    (g x)))) 

Stellen Sie sich vor, dass wir vor (define f ..) die anderen freien Variablen definieren.

((lambda (i) 
    ((lambda (h) 
     ((lambda (g) 
     ((lambda (f) 
      rest-of-program ...) 
      (lambda (x) 
      ((lambda (gx) 
       (i gx (h gx))) 
      (g x))))) 
     (lambda (v) g-expression))) 
    (lambda (v) h-expression))) 
(lambda (v1 v2) i-expression)) 

Die wirkliche Expansion etwas mehr sein könnte komplex, wenn eine der gebundenen Variablen tatsächlich benötigt, um eine Bindung zu haben, die weiter in waren in seiner Schließung, aber für Primitive dies funktioniert: Das kann neu geschrieben werden.