Kann jemand helfen, dieses Schema -Verfahren zu erklären

Question

Frage:

((lambda (x y) (x y)) (lambda (x) (* x x)) (* 3 3))

Dies war die Nummer 1 auf die Zwischenzeit, ich habe "81 9" gestellt, er dachte, ich hätte vergessen, einen Lawl zu überqueren, also überquere ich 81 und er geht aww. Wie auch immer, ich verstehe nicht, warum es 81 ist.

ich verstehe warum (lambda (x) (* x x)) (* 3 3) = 81, aber das erste lambda, ich verstehe nicht, was die x- und y -Werte da sind und was die [body] (x y) tut.

Ich hatte also gehofft, dass mir jemand erklären konnte, warum der erste Teil nicht so aussieht.

Answer 1

Dies braucht eine Einrückung, um zu klären

((lambda (x y) (x y))
 (lambda (x) (* x x))
 (* 3 3))

• (lambda (x y) (x y)); Anruf x mit y als nur Parameter.
• (lambda (x) (* x x)); Bewerten Sie auf das Quadrat seines Parameters.
• (* 3 3); bewerten auf 9

Das Ganze bedeutet also: "Rufen Sie die quadratische Funktion mit dem 9 als Parameter auf".

Bearbeiten: Das Gleiche könnte geschrieben werden wie

((lambda (x) (* x x))
 (* 3 3))

Ich denke, die Absicht der Übung ist es, hervorzuheben, wie die Bewertung eines Schemasformulars eine implizite Funktionsanwendung beinhaltet.

Answer 2

Schauen wir uns das noch einmal an ...

((lambda (x y) (x y)) (lambda (x) (* x x)) (* 3 3))

Um ein Formular zu bewerten, bewerten wir jeden Teil davon nacheinander. Wir haben drei Elemente in unserer Form. Dieser befindet sich in der ersten (Funktion) Position:

(lambda (x y) (x y))

Dies ist ein zweites Element einer Form und ein erstes Argument für die Funktion:

(lambda (x) (* x x))

Letzte Element der Form, also ein zweites Argument für die Funktion.

(* 3 3)

Die Reihenfolge der Bewertung spielt in diesem Fall keine Rolle. Beginnen wir einfach von links.

(lambda (x y) (x y))

Lambda erstellt eine Funktion, sodass dies eine Funktion bewertet, die zwei Argumente annimmt, x und y, und dann X auf Y anwendet (mit anderen Worten, ruft X mit einem einzigen Argument y auf). Nennen wir das Anruf-1.

(lambda (x) (* x x))

Dies bewertet eine Funktion, die ein einziges Argument annimmt und ein Quadrat dieses Arguments zurückgibt. Also können wir das einfach nennen Quadrat.

(* 3 3)

Dies bewertet offensichtlich zu 9.

OK, also nach dieser ersten Bewertung haben wir:

(call-1 square 9)

Um dies zu bewerten, rufen wir an Anruf-1 mit zwei Argumenten, Quadrat und 9. Bewirbt sich Anruf-1 gibt uns:

(square 9)

Da ist das was Anruf-1 tut - es nennt sein erstes Argument mit seinem zweiten Argument. Jetzt Quadrat von 9 ist 81, was der Wert des gesamten Ausdrucks ist.

Answer 3

Vielleicht hilft es, diesen Code in das gemeinsame Lisp zu übersetzen, das Verhalten zu klären:

((lambda (x y) (funcall x y)) (lambda (x) (* x x)) (* 3 3))

Oder noch expliziter:

(funcall (lambda (x y) (funcall x y))
         (lambda (x) (* x x))
         (* 3 3))

In der Tat tut diese erste Lambda nichts Nützliches, da es auf:

(funcall (lambda (x) (* x x)) (* 3 3))

was gleich ist

(let ((x (* 3 3)))
  (* x x))

gleich

(let ((x 9))
  (* x x))

gleich

(* 9 9)

gleich 81.

Answer 4

Die bisher geposteten Antworten sind gut. Anstatt zu duplizieren, was sie bereits sagten, können Sie sich vielleicht eine andere Möglichkeit ansehen, das Programm anzusehen:

(define (square x) (* x x))

(define (call-with arg fun) (fun arg))

(call-with (* 3 3) square)

Sieht es immer noch seltsam aus?