¿En qué lenguaje de programación apareció "let" por primera vez?

Me preguntaba sobre los orígenes del "let" utilizado en Lisp, Clojure y Haskell. ¿Alguien sabe en qué idioma apareció primero?

Bueno, BASIC tenía LETuna asignación como parte de la sintaxis desde el comienzo en 1964, por lo que sería anterior al uso de letLisp, que, como señala Chris Jester-Young, no apareció hasta la década de 1970 según Evolution of Lisp .

Tampoco creo que COBOL, Fortran o ALGOL tengan LETen su sintaxis. Entonces voy a ir con BASIC.

Me gustaría agregar un punto de vista teórico: en los cálculos lambda clásicos, letes solo azúcar sintáctico. Por ejemplo

let x = N in M

puede reescribirse simplemente como

(λx.M)N

Por lo tanto, su primera aparición en los primeros lenguajes (funcionales) no es tan interesante.

Sin embargo, se vuelve muy importante con la invención del sistema de tipos Hindley-Milner y su algoritmo de inferencia de tipos. En este tipo de sistema letes indispensable, porque es polimórfico (a diferencia de la abstracción λ en HM). Por ejemplo, considere esta simple expresión:

let id = λx . x in id id

Aquí ides polimórfico, tiene tipo ∀α.α → αy, por lo tanto id id, verificaciones de tipo: su tipo es id id : τ → τpara τ arbitrario. (Por primera idasignamos τ → τa αy para la segunda idasignamos τa α.)

Sin embargo, no podemos reescribirlo usando la abstracción λ y la aplicación. Expresión

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

no escribir-cheque, porque dentro de la primera abstracción λ idse le debe asignar un tipo monomórfica id : σpara algunos σ, y no hay σ tal que podríamos aplicar id : σa id : σ.

Puedes probar esto tú mismo en Haskell. Mientras se let id = \x -> x in id id :: t -> tverifican los tipos, la escritura (\id -> id id)(\x -> x)falla con

Se produce la comprobación: no se puede construir el tipo infinito: t0 = t0 -> t0
en el primer argumento de id, a saber, id
en la expresión: id id
en la expresión:\id -> id id

Lisp es el idioma más antiguo de estos que tiene LET ahora . Pero BASIC fue el primero que lo consiguió, porque Lisp lo había obtenido mucho más tarde.

En Ada Lovelace Analytical Engine (1843), sin LET, un programa se ve así:

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

En Plankalkül of Zuse (1943-45) el programa se ve:

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

Código corto fue propuesto por John Mauchly en 1949

X3 =  (  X1 +  Y1 )  /  X1 * Y1   

PL intermedio de Burks, 1950, utilizado para asignación ->

Rutishauser en 1952 usado =>=

Compilador de Böhms, 1952, usado ->

En la Universidad de Manchester, Alick Glennie se desarrolló Autocodea principios de la década de 1950. El primer código y compilador se desarrolló en 1952 para la computadora Mark 1 de la Universidad de Manchester y se considera el primer lenguaje de programación compilado de alto nivel. De nuevo, ->para asignación

Charles Adams, FORTRAN 0 del grupo de Backus, Autocode 2 de Brooker, ПП1 de Lubimsky y Kamynin; todo en 1954, nuevamente=

BACAIC (Grems, Porter), 1954, *para asignación.

Kompiler, ADES, 1955, =

IT, 1956, <-

FORTRAN, 1957, =

AT-3 (1956), Math-Matic (1957), de nuevo =,

pero Flow-Matic en 1957 tenía dos tareas, y ambas están en palabras

TRANSFER a TO b y MOVE a TO b

La máquina de Bauer y Samelson, 1957: =>

Lo sentimos, no puedo abarcar todos los idiomas entre 1957 y 1964, pero los idiomas más grandes

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)

no he dejado para la asignación. O no lo había hecho , en el caso de LISP.

Dartmouth BASIC es la versión original del lenguaje de programación BASIC. La primera versión interactiva se puso a disposición de los usuarios generales en junio de 1964 ;

 LET / = — assign formula results to a variable

Bueno, entre esos tres, Lisp definitivamente lo tuvo primero. Haskell surgió en los años 80 y Clojure en los años 00, y lethabía existido mucho antes de cualquiera de esas fechas. :-)

En cuanto a si Lisp fue el lenguaje que lo inventó, todavía no puedo responder por eso, pero investigaré un poco y veré. :-)

Actualización: Según Evolution of Lisp (ver página 46), mencionó que letfue inventado en los años 70:

LET—En sí mismo, una macro inventada por primera vez y reinventada localmente en cada sitio— fue un recién llegado al mundo de MacLisp; según Lisp Archive, fue absorbido retroactivamente en PDP-10 MacLisp desde Lisp-Machine Lisp en 1979 al mismo tiempo que DEFMACROla compleja DEFUNsintaxis de argumentos de Lisp Machine .

Todavía no responde si fue inventado en otro idioma antes, por supuesto, pero aún otro punto de datos. :-)

El primer informe revisado del esquema AIM-452 de enero de 1978 tiene LET. Página 9.

tenga en cuenta que Lisp utilizó anteriormente una construcción diferente PROGpara introducir variables locales.

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

habría sido escrito anteriormente aproximadamente como

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