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?
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?
Réponses:
Eh bien, BASIC avait LET
pour affectation dans le cadre de la syntaxe depuis le début en 1964, ce qui serait antérieur à l'utilisation de let
Lisp, 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 LET
dans leur syntaxe. Je vais donc aller avec BASIC.
let
en base n'est pas une liaison à portée lexicale. Ainsi, la bonne réponse serait quelque chose comme "il est apparu pour la première fois en anglais, avant le 12ème siècle".
let
dans ce contexte ( let
x is
quelque chose in
l'expression suivante) est apparu pour la première fois dans des textes mathématiques en anglais, et c'est là qu'il est entré dans la programmation. Je ne vois aucune différence entre les systèmes formels - langages mathématiques, langages de programmation, quoi que ce soit d'autre - ils sont tous les mêmes.
equals
dire non is
. Et, oui, le pseudo-code est la meilleure réponse à ce jour.
Je voudrais ajouter un point de vue théorique: dans les calculs lambda classiques, let
c'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 let
est indispensable, car il est polymorphe (contrairement à λ-abstraction en HM). Par exemple, considérez cette expression simple:
let id = λx . x in id id
Voici id
polymorphe, il a du type ∀α.α → α
, et donc id id
des vérifications de type - son type est id id : τ → τ
pour τ arbitraire. (Pour le premier, id
nous attribuons τ → τ
à α
et pour le second, id
nous 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 λ id
doit ê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 -> t
vé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 deid
, à savoirid
Dans l'expression:id id
Dans l'expression:\id -> id id
a[i]
notation de C est du sucre syntaxique pour *(a + i)
. L'article Wikipédia a également une belle explication.
let
l'introduction de
let
introduit, comme la question commence par je me demandais les origines du "let" ...
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 let
avait 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 queDEFMACRO
laDEFUN
syntaxe 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 PROG
pour 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))
let
toujours une portée lexicale dans les dialectes lisp?
let
peu près aussi ancien que la portée lexicale (Scheme, '75), et il a fallu un certain temps pour que la portée lexicale soit acceptée, donc je suppose que les premières instances de let
étaient dans le contexte de Lisps à portée dynamique. Aujourd'hui, Emacs Lisp a toujours une portée dynamique par défaut, avec lambda
et let
(ce dernier sucre pour le premier de toute façon) liant dynamiquement leurs paramètres.