In quale linguaggio di programmazione è apparso "let" per la prima volta?

Bene, BASIC ha avuto LET per l'assegnazione come parte della sintassi dal inizia nel 1964, in modo da precedere l'uso di let in Lisp, che come sottolineava Chris Jester-Young non apparve fino agli anni '70 secondo Evolution of Lisp .

Non credo che COBOL, Fortran o ALGOL abbiano LET nella loro sintassi. Quindi vado con BASIC.

Vorrei aggiungere un punto di vista teorico: nei calcoli lambda classici, let è solo zucchero sintattico. Ad esempio

let x = N in M

può essere riscritto semplicemente come

(λx.M)N

Quindi la sua prima apparizione nelle prime lingue (funzionali) non è così interessante.

Tuttavia, diventa molto importante con l'invenzione del sistema di tipo Hindley-Milner e il suo algoritmo di inferenza del tipo. In questo tipo di sistema let è indispensabile, perché è polimorfico (a differenza di λ-astrazione in HM). Ad esempio, considera questa semplice espressione:

let id = λx . x in id id

Qui id è polimorfico, ha type ∀α.α → α , e quindi id id type-checks - il suo tipo è id id : τ → τ per arbitrario τ. (Per il primo id assegniamo τ → τ a α e per il secondo id assegniamo τ a α .)

Tuttavia, non possiamo riscriverlo usando l'astrazione e l'applicazione λ. Espressione

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

non controlla i caratteri, poiché all'interno della prima astrazione λ id deve essere assegnato un tipo monomorfico id : σ per alcuni σ, e non esiste σ tale che potremmo applicare id : σ a id : σ .

Puoi provare tu stesso in Haskell. Mentre let id = \x -> x in id id :: t -> t controlla-tipo, digitando (\id -> id id)(\x -> x) fallisce con

Occurs check: cannot construct the infinite type: t0 = t0 -> t0
In the first argument of id, namely id
In the expression: id id
In the expression: \id -> id id

Il Lisp è la lingua più vecchia di questi con LET ora . Ma BASIC è stato il primo a ottenerlo, perché Lisp l'aveva ottenuto molto più tardi.

In Ada Lovelace Analytical Engine (1843) - no LET, un programma appare come:

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

In Plankalkül of Zuse (1943-45) il programma sembra:

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

Il codice corto è stato proposto da John Mauchly nel 1949

X3 =  (  X1 +  Y1 )  /  X1 * Y1   

PL intermedio di Burks, 1950, utilizzato per l'assegnazione ->

Rutishauser nel 1952 usava =>=

Compilatore di Böhms, 1952, usato ->

All'università di Manchester, Alick Glennie ha sviluppato Autocode nei primi anni '50. Il primo codice e compilatore è stato sviluppato nel 1952 per il computer Mark 1 presso l'Università di Manchester ed è considerato il primo linguaggio di programmazione di alto livello compilato. Di nuovo, -> per l'assegnazione

Charles Adams, FORTRAN 0 del gruppo di Backus, Autocodice 2 di Brooker, ПП1 di Lubimsky e Kamynin; tutto nel 1954, nuovamente =

BACAIC (Grems, Porter), 1954, * per l'assegnazione!

Kompiler, ADES, 1955, =

IT, 1956, <-

FORTRAN, 1957, =

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

ma Flow-Matic nel 1957 aveva due incarichi, ed entrambi sono in parole

TRANSFER a TO b e MOVE a TO b

Macchina di Bauer e Samelson, 1957: =>

Siamo spiacenti, non posso coprire tutte le lingue tra il 1957 e il 1964, ma lingue più grandi

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)

non hanno LET per incarico. O non aveva , nel caso di LISP.

Dartmouth BASIC è la versione originale del linguaggio di programmazione BASIC. La prima versione interattiva è stata resa disponibile agli utenti generici in giugno 1964 ;

 LET / = — assign formula results to a variable

Bene, tra quei tre, Lisp lo ha avuto sicuramente per primo. Haskell è nato negli anni '80 e Clojure negli anni 00 e let era stato intorno a lungo prima di una di quelle date. : -)

Per quanto riguarda il fatto che Lisp sia stato il linguaggio per averlo inventato, non posso ancora pronunciarlo, ma farò qualche ricerca e vedrò. : -)

Aggiornamento: in base a Evolution of Lisp (vedere pagina 46), ha menzionato che let è stato inventato negli anni '70:

LET—itself a macro first invented and reinvented locally at each site—was a late-comer to the MacLisp world; according to Lisp Archive, it was retroactively absorbed into PDP-10 MacLisp from Lisp-Machine Lisp in 1979 at the same time as DEFMACRO and the complex Lisp Machine DEFUN argument syntax.

Ancora non rispondo del tutto se è stato inventato in un'altra lingua prima, ovviamente, ma ancora un altro punto di dati. : -)

Il primo rapporto Revised Scheme AIM-452 del gennaio 1978 ha LET . Pagina 9.

nota che il Lisp ha usato prima un diverso costrutto PROG per introdurre le variabili locali.

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

sarebbe stato scritto prima approssimativamente come

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