In quale linguaggio di programmazione è apparso prima "let"?

Mi chiedevo quali fossero le origini del "let" utilizzato in Lisp, Clojure e Haskell. Qualcuno sa in quale lingua è apparso per primo?

Bene, BASIC aveva LETper incarico come parte della sintassi fin dall'inizio nel 1964, quindi questo avrebbe preceduto l'uso di letLisp, che come sottolinea Chris Jester-Young non apparve fino agli anni '70 secondo Evolution of Lisp .

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

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

let x = N in M

può essere riscritto semplicemente come

(λx.M)N

Quindi la sua prima apparizione nelle prime lingue (funzionali) non è poi 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 dell'astrazione λ in HM). Ad esempio, considera questa semplice espressione:

let id = λx . x in id id

Qui idè polimorfico, ha tipo ∀α.α → αe quindi id idcontrolli di tipo - il suo tipo è id id : τ → τper τ arbitrario. (Per il primo idassegniamo τ → τa αe per la seconda idassegniamo τper α.)

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

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

non tipo-controllo, perché all'interno della prima astrazione λ iddeve essere assegnato un tipo monomorfica id : σper qualche σ, e non c'è σ tale che potremmo applicare id : σa id : σ.

Puoi provarlo tu stesso in Haskell. Durante let id = \x -> x in id id :: t -> ti controlli del tipo, la digitazione (\id -> id id)(\x -> x)non riesce

Verifica occorrente: impossibile costruire il tipo infinito: t0 = t0 -> t0
nel primo argomento di id, ovvero id
nell'espressione: id id
nell'espressione:\id -> id id

Lisp è il linguaggio più antico di questi che hanno LET ora . Ma BASIC fu il primo ad ottenerlo, perché Lisp l'aveva ottenuto molto più tardi.

In Ada Lovelace Analytical Engine (1843) - nessuna LET, un programma si presenta come:

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

Nel Plankalkül di Zuse (1943-45) il programma appare:

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 fu proposto da John Mauchly nel 1949

X3 =  (  X1 +  Y1 )  /  X1 * Y1   

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

Rutishauser nel 1952 usato =>=

Compilatore Böhms, 1952, usato ->

All'università di Manchester, Alick Glennie si sviluppò Autocodenei primi anni '50. Il primo codice e compilatore fu sviluppato nel 1952 per il computer Mark 1 all'Università di Manchester ed è considerato il primo linguaggio di programmazione ad alto livello compilato. Ancora una volta, ->per incarico

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

BACAIC (Grems, Porter), 1954, *per incarico!

Kompiler, ADES, 1955, =

IT, 1956, <-

FORTRAN, 1957, =

AT-3 (1956), Math-Matic (1957), di nuovo =,

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

TRANSFER a TO b e MOVE a TO b

La 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 LET per l'assegnazione. O no , nel caso di LISP.

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

 LET / = — assign formula results to a variable

Bene, tra questi tre, Lisp lo ha sicuramente avuto per primo. Haskell nacque negli anni '80 e Clojure negli anni '00, ed letera stato in giro molto prima di una di quelle date. :-)

Se Lisp fosse la lingua per averlo inventato, non posso ancora garantirlo, ma farò qualche ricerca e vedrò. :-)

Aggiornamento: Secondo Evolution of Lisp (vedi pagina 46), ha affermato che è letstato inventato negli anni '70:

LET—Se una macro inventata e reinventata per la prima volta localmente in ogni sito — è stata una novità per il mondo MacLisp; secondo Lisp Archive, è stato assorbito retroattivamente in MacLisp PDP-10 da Lisp-Machine Lisp nel 1979 contemporaneamente DEFMACROalla complessa DEFUNsintassi dell'argomento Lisp Machine .

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

La prima relazione sullo schema rivisto AIM-452 del gennaio 1978 ha LET. Pagina 9

si noti che Lisp ha usato in precedenza un costrutto diverso PROGper introdurre 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))