In welcher Programmiersprache ist „let“ zuerst aufgetaucht?

Ich wunderte mich über die Ursprünge des Let in Lisp, Clojure und Haskell. Weiß jemand, in welcher Sprache es zuerst erschien?

Nun, BASIC musste LETvon Anfang an 1964 als Teil der Syntax zugewiesen werden, damit dies vor der Verwendung letin Lisp stattfand, was laut Evolution of Lisp , wie Chris Jester-Young betont, erst in den 1970er Jahren auftrat .

Ich glaube nicht, dass COBOL, Fortran oder ALGOL LETin ihrer Syntax haben. Also werde ich mit BASIC gehen.

Ich möchte eine theoretische Sichtweise hinzufügen: In der klassischen Lambda-Rechnung letist es nur syntaktischer Zucker. Beispielsweise

let x = N in M

kann einfach umgeschrieben werden als

(λx.M)N

Daher ist sein erster Auftritt in frühen (funktionalen) Sprachen nicht so interessant.

Es wird jedoch mit der Erfindung des Hindley-Milner- Typ-Systems und seines Typ-Inferenz-Algorithmus sehr wichtig . In diesem Typ System letist unverzichtbar, weil es polymorph ist (im Gegensatz zu λ-Abstraktion in HM). Betrachten Sie beispielsweise diesen einfachen Ausdruck:

let id = λx . x in id id

Hier idist polymorph, es hat Typ ∀α.α → αund daher id idTypprüfungen - sein Typ ist id id : τ → τfür willkürliches τ. (Für den ersten idwir assign τ → τzu αund für die zweiteid wir assign τfür α.)

Wir können es jedoch nicht mit λ-Abstraktion und -Anwendung umschreiben. Ausdruck

(λid . id id)(λx.x)

nicht geben Prüfung, weil innerhalb der ersten λ Abstraktion idmuss einen monomorphen Typ zugeordnet werden id : σfür einige σ, und es gibt keine σ , so dass wir anwenden könnten id : σzu id : σ.

Sie können dies selbst in Haskell versuchen. Während der let id = \x -> x in id id :: t -> tTypprüfung (\id -> id id)(\x -> x)schlägt die Eingabe mit fehl

Tritt ein check: kann den unendlichen Typ nicht konstruieren: t0 = t0 -> t0
Im ersten Argument von id, nämlich id
Im Ausdruck: id id
Im Ausdruck:\id -> id id

Lisp ist die älteste Sprache von diesen, die LET jetzt hat . Aber BASIC war das erste, das es bekam, denn Lisp hatte es viel später erhalten.

In Ada Lovelace Analytical Engine (1843) - no LET sieht ein Programm folgendermaßen aus:

N0 6 N1 1 N2 1 × L1 L0 S1  L0 L2 S0 L2 L0 CB?11 '

In Plankalkül von Zuse (1943-45) sieht das Programm so aus:

P1 max3 (V0[:8.0],V1[:8.0],V2[:8.0]) → R0[:8.0]
max(V0[:8.0],V1[:8.0]) → Z1[:8.0]
max(Z1[:8.0],V2[:8.0]) → R0[:8.0]
END

Short Code wurde 1949 von John Mauchly vorgeschlagen

X3 =  (  X1 +  Y1 )  /  X1 * Y1   

Intermediate PL of Burks, 1950, für die Zuordnung verwendet ->

Rutishauser 1952 benutzt =>=

Böhms-Compiler, 1952, gebraucht ->

An der Universität von Manchester entwickelte sich Alick Glennie Autocodein den frühen 1950er Jahren. Der erste Code und Compiler wurde 1952 für den Mark 1-Computer an der Universität von Manchester entwickelt und gilt als die erste kompilierte Programmiersprache auf hohem Niveau. Wieder ->für die Zuordnung

Charles Adams, FORTRAN 0 von Backus 'Gruppe, Brookers Autocode 2, ПП1 von Lubimsky und Kamynin; alles wieder im Jahr 1954=

BACAIC (Grems, Porter), 1954, *für den Auftrag!

Kompiler, ADES, 1955, =

IT, 1956, <-

Fortran, 1957, =

AT-3 (1956), wieder Math-Matic (1957) = ,

aber Flow-Matic im Jahr 1957 hatte zwei Aufgaben, und beide sind in Worten

TRANSFER a TO b und MOVE a TO b

Bauer und Samelsons Maschine, 1957: =>

Entschuldigung, ich kann nicht alle Sprachen zwischen 1957 und 1964 behandeln, aber größere Sprachen

1957 - COMTRAN (forerunner to COBOL)
1958 - LISP
1958 - ALGOL 58
1959 - FACT (forerunner to COBOL)
1959 - COBOL
1959 - RPG
1962 - APL
1962 - Simula
1962 - SNOBOL
1963 - CPL (forerunner to C)

habe nicht für die Zuordnung LASSEN. Oder nicht , im Falle von LISP.

Dartmouth BASIC ist die Originalversion der Programmiersprache BASIC. Die erste interaktive Version wurde den allgemeinen Nutzern im Juni 1964 zur Verfügung gestellt .

 LET / = — assign formula results to a variable

Nun, zwischen diesen drei hatte es Lisp definitiv zuerst. Haskell entstand in den 80ern und Clojure in den 00ern und letwar in der Nähe gewesen lange vor diesen beiden Daten . :-)

Zur Frage , ob Lisp war die Sprache war, die es erfunden hat, kann ich noch nicht bezeugen, aber ich werde ein bisschen recherchieren und nachsehen. :-)

Update: Laut Evolution of Lisp (siehe Seite 46) wurde erwähnt, dass letes in den 70er Jahren erfunden wurde:

LET- selbst ein Makro, das zuerst vor Ort erfunden und neu erfunden wurde - war ein Spätankömmling in der MacLisp-Welt; Laut Lisp Archive wurde es 1979 von Lisp-Machine Lisp gleichzeitig mit DEFMACROder komplexen DEFUNArgument-Syntax von Lisp Machine rückwirkend in PDP-10 MacLisp aufgenommen .

Immer noch nicht ganz beantwortet, ob es früher in einer anderen Sprache erfunden wurde, aber immer noch ein anderer Datenpunkt. :-)

Der erste überarbeitete Schemabericht AIM-452 vom Januar 1978 hat LET. Seite 9.

Beachten Sie, dass Lisp früher ein anderes Konstrukt verwendet hat PROG, um lokale Variablen einzuführen.

(let ((a 1)
      (b 1))
  (+ a b))

wäre früher ungefähr als geschrieben worden

(prog (a b)
  (setq a 1)
  (setq b 1)
  (+ a b))