LET versus LET* in Common Lisp

Question

Ich verstehe den Unterschied zwischen LET und LET* (parallele und sequentielle Bindung), und theoretisch macht das auch durchaus Sinn. Aber gibt es einen Fall, in dem Sie LET jemals wirklich gebraucht haben? In all meinem Lisp-Code, den ich mir in letzter Zeit angesehen habe, könnte man jedes LET durch LET* ersetzen, ohne dass sich etwas ändert.

Edit: OK, ich verstehe warum Irgendjemand hat LET* erfunden, vermutlich als Makro, vor langer Zeit. Meine Frage ist, ob es angesichts der Existenz von LET* einen Grund gibt, LET beizubehalten? Haben Sie schon einmal Lisp-Code geschrieben, in dem ein LET* nicht so gut funktioniert wie ein einfaches LET?

Ich glaube nicht an das Argument der Effizienz. Erstens scheint es nicht so schwer zu sein, Fälle zu erkennen, in denen LET* in etwas so Effizientes wie LET kompiliert werden kann. Zweitens gibt es eine Menge Dinge in der CL-Spezifikation, die einfach nicht so aussehen, als wären sie auf Effizienz ausgelegt. (Wann haben Sie das letzte Mal eine LOOP mit Typdeklarationen gesehen? Die sind so schwer zu verstehen, dass ich sie noch nie benutzt gesehen habe.) Vor Dick Gabriels Benchmarks in den späten 1980er Jahren war CL war geradezu langsam.

Es sieht so aus, als sei dies ein weiterer Fall von Abwärtskompatibilität: wohlweislich wollte niemand riskieren, etwas so Grundlegendes wie LET zu zerstören. Das war meine Vermutung, aber es ist beruhigend zu hören, dass niemand einen dumm-einfachen Fall hat, den ich übersehen habe, in dem LET eine Reihe von Dingen lächerlich einfacher gemacht hat als LET*.

Answer 1

LET selbst ist kein echtes Primitivum in einer Funktionale Programmiersprache ersetzt werden kann, da sie durch LAMBDA . Etwa so:

(let ((a1 b1) (a2 b2) ... (an bn))
  (some-code a1 a2 ... an))

ist vergleichbar mit

((lambda (a1 a2 ... an)
   (some-code a1 a2 ... an))
 b1 b2 ... bn)

Aber

(let* ((a1 b1) (a2 b2) ... (an bn))
  (some-code a1 a2 ... an))

ist vergleichbar mit

((lambda (a1)
    ((lambda (a2)
       ...
       ((lambda (an)
          (some-code a1 a2 ... an))
        bn))
      b2))
   b1)

Sie können sich vorstellen, was einfacher ist. LET und nicht LET* .

LET macht den Code leichter verständlich. Man sieht ein Bündel von Bindungen und kann jede Bindung einzeln lesen, ohne den Top-Down-/Links-Rechts-Fluss der "Effekte" (Rückbindungen) verstehen zu müssen. Verwendung von LET* signalisiert dem Programmierer (demjenigen, der den Code liest), dass die Bindungen nicht unabhängig sind, sondern dass es eine Art Top-Down-Fluss gibt - was die Sache verkompliziert.

Common Lisp hat die Regel, dass die Werte für die Bindungen in LET werden von links nach rechts berechnet. Genau wie die Werte für einen Funktionsaufruf ausgewertet werden - von links nach rechts. So, LET ist die konzeptionell einfachere Anweisung und sollte standardmäßig verwendet werden.

Typen in LOOP ? werden recht häufig verwendet. Es gibt einige primitive Formen der Typendeklaration, die leicht zu merken sind. Beispiel:

(LOOP FOR i FIXNUM BELOW (TRUNCATE n 2) do (something i))

Oben wird die Variable i zu sein fixnum .

Richard P. Gabriel veröffentlichte 1985 sein Buch über Lisp-Benchmarks, und zu dieser Zeit wurden diese Benchmarks auch mit Nicht-CL-Lisp verwendet. Common Lisp selbst war 1985 brandneu - die CLtL1 Das Buch, in dem die Sprache beschrieben wird, war gerade 1984 erschienen. Kein Wunder, dass die Implementierungen zu dieser Zeit nicht sehr optimiert waren. Die implementierten Optimierungen waren im Grunde die gleichen (oder weniger), die die Implementierungen davor hatten (wie MacLisp).

Aber für LET vs. LET* Der Hauptunterschied besteht darin, dass Code mit LET ist für Menschen leichter zu verstehen, da die Bindungsklauseln unabhängig voneinander sind - zumal es schlechter Stil ist, die Auswertung von links nach rechts auszunutzen (ohne Variablen als Nebeneffekt zu setzen).

Answer 2

Sie haben keine brauchen LET, aber normalerweise wollen il.

LET deutet darauf hin, dass Sie nur eine Standard-Parallelbindung durchführen, ohne dass es irgendwelche Schwierigkeiten gibt. LET* führt zu Einschränkungen für den Compiler und suggeriert dem Benutzer, dass es einen Grund gibt, warum sequentielle Bindungen erforderlich sind. In Bezug auf Stil LET ist besser, wenn Sie die zusätzlichen Einschränkungen von LET* nicht brauchen.

Es kann effizienter sein, LET als LET* zu verwenden (je nach Compiler, Optimierer usw.):

• parallele Bindungen können sein parallel ausgeführt (aber ich weiß nicht, ob irgendwelche LISP-Systeme dies tatsächlich tun, und die Init-Formulare müssen immer noch sequentiell ausgeführt werden)
• Parallele Bindungen schaffen eine einzige neue Umgebung (Scope) für alle Bindungen. Sequentielle Bindungen erstellen eine neue verschachtelte Umgebung für jede einzelne Bindung. Parallele Bindungen verwenden weniger Speicherplatz und haben schnelleres Nachschlagen von Variablen .

(Die obigen Aufzählungspunkte gelten für Scheme, einen anderen LISP-Dialekt. clisp kann davon abweichen.)

Answer 3

Ich komme mit erfundenen Beispielen. Vergleichen Sie das Ergebnis:

(print (let ((c 1))
         (let ((c 2)
               (a (+ c 1)))
           a)))

mit dem Ergebnis der Durchführung dieses Vorgangs:

(print (let ((c 1))
         (let* ((c 2)
                (a (+ c 1)))
           a)))

Answer 4

In LISP besteht oft der Wunsch, die schwächsten möglichen Konstrukte zu verwenden. Einige Styleguides empfehlen die Verwendung von = statt eql wenn Sie wissen, dass die verglichenen Elemente numerisch sind, zum Beispiel. Oft geht es eher darum, zu spezifizieren, was man meint, als den Computer effizient zu programmieren.

Es kann jedoch zu tatsächlichen Effizienzsteigerungen führen, wenn man nur sagt, was man meint, und keine stärkeren Konstrukte verwendet. Wenn Sie Initialisierungen mit LET können sie parallel ausgeführt werden, während LET* Initialisierungen müssen sequentiell ausgeführt werden. Ich weiß nicht, ob es Implementierungen gibt, die das tatsächlich tun, aber einige werden es in Zukunft vielleicht tun.

Answer 5

Der Hauptunterschied in Common List zwischen LET und LET* besteht darin, dass die Symbole in LET parallel und in LET* sequentiell gebunden werden. Bei der Verwendung von LET können die Init-Formulare nicht parallel ausgeführt werden, und die Reihenfolge der Init-Formulare kann nicht geändert werden. Der Grund dafür ist, dass Common Lisp Funktionen mit Seiteneffekten erlaubt. Daher ist die Reihenfolge der Auswertung wichtig und erfolgt innerhalb eines Formulars immer von links nach rechts. In LET werden also zuerst die Init-Formulare von links nach rechts ausgewertet, dann werden die Bindungen erstellt, von links nach rechts parallel zueinander. In LET* wird die Init-Form ausgewertet und dann der Reihe nach von links nach rechts an das Symbol gebunden.

CLHS: Spezialoperator LET, LET*