Dans quel langage de programmation «laisser» est-il apparu en premier?

Je m'interrogeais sur les origines du «let» utilisé à Lisp, Clojure et Haskell. Quelqu'un sait-il dans quelle langue il est apparu en premier?

Eh bien, BASIC avait LETpour affectation dans le cadre de la syntaxe depuis le début en 1964, ce qui serait antérieur à l'utilisation de letLisp, qui, comme le souligne Chris Jester-Young, n'est apparu que dans les années 1970 selon Evolution of Lisp .

Je ne crois pas non plus que COBOL, Fortran ou ALGOL aient LETdans leur syntaxe. Je vais donc aller avec BASIC.

Je voudrais ajouter un point de vue théorique: dans les calculs lambda classiques, letc'est juste du sucre syntaxique. Par exemple

let x = N in M

peut être réécrit simplement

(λx.M)N

Sa première apparition dans les premiers langages (fonctionnels) n'est donc pas si intéressante.

Cependant, il devient très important avec l'invention du système de type Hindley-Milner et de son algorithme d'inférence de type. Dans ce type de système letest indispensable, car il est polymorphe (contrairement à λ-abstraction en HM). Par exemple, considérez cette expression simple:

let id = λx . x in id id

Voici idpolymorphe, il a du type ∀α.α → α, et donc id iddes vérifications de type - son type est id id : τ → τpour τ arbitraire. (Pour le premier, idnous attribuons τ → τà αet pour le second, idnous attribuons τpour α.)

Cependant, nous ne pouvons pas le réécrire en utilisant l'abstraction et l'application λ. Expression

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

ne tape-contrôle pas, parce que dans la première abstraction λ iddoit être assigné à un type monomorphe id : σpour certains σ, et il n'y a pas σ telle que nous pourrions appliquer id : σà id : σ.

Vous pouvez l'essayer vous-même à Haskell. Pendant la let id = \x -> x in id id :: t -> tvérification de type, la saisie (\id -> id id)(\x -> x)échoue avec

Se produit vérification: ne peut pas construire le type infini: t0 = t0 -> t0
Dans le premier argument de id, à savoir id
Dans l'expression: id id
Dans l'expression:\id -> id id

Le lisp est la langue la plus ancienne de ceux-ci ayant LET maintenant . Mais BASIC a été le premier à l'obtenir, car Lisp l'a obtenu bien plus tard.

Dans Ada Lovelace Analytical Engine (1843) - no LET, un programme se présente comme suit:

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

Dans Plankalkül of Zuse (1943-45), le programme ressemble à:

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 a été proposé par John Mauchly en 1949

X3 =  (  X1 +  Y1 )  /  X1 * Y1   

PL intermédiaire de Burks, 1950, utilisé pour l'affectation ->

Rutishauser en 1952 d'occasion =>=

Compilateur Böhms, 1952, d'occasion ->

À l'Université de Manchester, Alick Glennie a développé Autocode au début des années 1950. Le premier code et compilateur a été développé en 1952 pour l'ordinateur Mark 1 de l'Université de Manchester et est considéré comme le premier langage de programmation de haut niveau compilé. Encore une fois, ->pour l'affectation

Charles Adams, FORTRAN 0 du groupe de Backus, Brooker's Autocode 2, ПП1 de Lubimsky et Kamynin; tout en 1954, encore une fois=

BACAIC (Grems, Porter), 1954, *pour mission!

Kompiler, ADES, 1955, =

IT, 1956, <-

FORTRAN, 1957, =

AT-3 (1956), Math-Matic (1957), encore une fois = ,

mais Flow-Matic en 1957 avait deux missions, et les deux sont en mots

TRANSFER a TO b et MOVE a TO b

La machine de Bauer et Samelson, 1957: =>

Désolé, je ne peux pas couvrir toutes les langues entre 1957 et 1964, mais des langues plus 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)

n'ont pas LET pour la cession. Ou pas , dans le cas du LISP.

Dartmouth BASIC est la version originale du langage de programmation BASIC. La première version interactive a été mise à la disposition des utilisateurs généraux en juin 1964 ;

 LET / = — assign formula results to a variable

Eh bien, entre ces trois, Lisp l'a définitivement eu en premier. Haskell a vu le jour dans les années 80, et Clojure dans les années 00, et letavait existé bien avant l'une ou l'autre de ces dates. :-)

Quant à savoir si Lisp était la langue qui l'a inventé, je ne peux pas encore le garantir, mais je ferai des recherches et je verrai. :-)

Mise à jour: Selon Evolution of Lisp (voir page 46), il a mentionné qu'il a letété inventé dans les années 70:

LET- elle-même, une macro inventée et réinventée localement sur chaque site - était arrivée tardivement dans le monde MacLisp; selon Lisp Archive, il a été absorbé rétroactivement dans PDP-10 MacLisp de Lisp-Machine Lisp en 1979 en même temps que DEFMACROla DEFUNsyntaxe complexe de l' argument Lisp Machine .

Il ne répond toujours pas tout à fait s'il a été inventé dans une autre langue plus tôt, bien sûr, mais encore un autre point de données. :-)

Le premier rapport révisé du programme AIM-452 de janvier 1978 a LET . Page 9.

notez que Lisp a utilisé précédemment une construction différente PROGpour introduire des variables locales.

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

aurait été écrit plus tôt comme

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