Lambda-Syntax in Schema Sprache

Question

Ich lerne funktionale Programmierung. Eine Frage kam mir in den Sinn, als ich über die Einführung des Lambda-Abschnitts über FP las.

In Scheme the syntax for anonymous functions is the following one: 

(lambda (arg1...argn) body) 

... 

We can now easily define the compose function 

(define (compose f g) 
    (lambda (x) (f (g x)))) 

Ich kämpfe um x zu verstehen, ist es nicht in der Liste der Argumente der Definition von compose Funktion. also wie ist x eingegangen?

auch an, dass wir die Funktion g1 Argument genommen haben y, z, wie compose anrufen? compose (f1 g1) y z? Wenn das so ist, dann braucht es Argumente nicht nur zwei Funktionen, sondern auch die Argumente von g1. Ich bin sehr verwirrt.

Answer 1

Seit

(define (compose f g) 
    (lambda (x) (f (g x)))) 

wir

   (compose + *) 

haben ausgewertet

   (lambda (x) (+ (* x))). 

Das heißt, in

((compose + *) 42) 

wir

((compose + *) 42) 
=> ((lambda (x) (+ (* x))) 42) 
=> (+ (* 42)) 
=> (+ 42) 
=> 42 

Answer 2

Zunächst mit einer Liste um den Namen und die Argumente ist die Syntax Zucker erhalten. So versteht es läßt sie vollständig erweitern voll:

(define compose 
    (lambda (f g)  ; compose 
    (lambda (x)  ; body 
     (f (g x)))) 

Zunächst einmal bemerkt, dass der Name compose auf das Ergebnis der Auswertung des äußeren Lambda-Ausdrucks gegeben, und es wird eine zwei Argument Schließung.

Also, wenn Sie (compose f2 f1) aufrufen die Argumente Wetten an f gebunden und g und der Körper Ausdruck (lambda (x) (f (g x))) ausgewertet wird. Es wird eine Ein-Argument-Schließung. Sie könnten define hier verwenden:

Um diese Funktion zu verwenden, müssen Sie sie erneut aufrufen. So. (special-function 5) wäre das gleiche wie die Bewertung (f2 (f1 5)). Es ist leicht zu sehen, Substitutionsregeln zu verwenden.

Warum also das? Gut. Wir haben Funktionen, die eine Funktion übernehmen, wie map und statt zu schreiben:

(map (lambda (x) (f2 (f1 x))) '(1 2 3 4)) 

Sie

(map (compose f2 f1) '(1 2 3 4)) 

schreiben können, die im Wesentlichen dem gleichen Ausdruck ist ein wenig leichter.

Eine reale Welt compose Funktion nimmt tatsächlich eine beliebige Anzahl von Argumenten und es ist das letzte Argument, die Funktion, die zuerst angewendet wird, wird die Arität der resultierenden Funktion entscheiden. So in Schläger können Sie tun:

((compose add1 add1 *) 3 7) 
; ==> 23