LISP. C. Montangero Dipartimento d'informatica - Università di Pisa 2014

Transcript

1 LISP C. Montangero Dipartimento d'informatica - Università di Pisa 2014

2 John McCarthy Creatore del LISP LISt Processor, 1965 Time sharing memorandum, 1959 Thor, 1967 AI, dal 1956 con C. Shannon Premio Turing 1971

3 Sommario Il contesto storico Gli obiettivi Il nucleo funzionale del linguaggio sintassi semantica: sistema di transizioni semantica: l'interprete meta-circolare Le definizioni ricorsive L'incidente del binding dinamico Le liste di proprietà e il gc Conclusioni: un assessment di parte

4 La trimurti dei tardi anni '50 FORTRAN COBOL LISP (formule/array) (record/file) (simboli) John Backus ('77) Grace Hopper John McCarthy ('71)

5 Algol60 McCarthy Bauer Backus ( 78) Naur ('05) Perlis ('66) Sintassi formale (BNF), scoping statico, sistema di tipi call by name

6 LISP: obiettivi applicativi Elaborazione simbolica list processing, ossia manipolazione di formule logiche (prova programmi, AI) di analisi (derivazione, integrazioni) programmi interpretazione/compilazione trasformazione verifica alberi di ricerca AI (non-determinismo)

7 Esempio Dimostrazione automatica: Riconoscere P(a) come P[x/a] verificare la corrispondenza tra x e a Costruire Q[x/a] sostituendo ogni "x" (libero) in Q con "a"

8 Esempio: giochi

9 LISP: obiettivi teorici Trattare i linguaggi come oggetti matematici "ragionar sui programmi" to use a prefix notation (emphasizing the operator rather than the operands of an expression); to use the concept of function as widely as possible; to provide higher order functions and hence a notation for functions (based on Church s (1941) λ-notation); es: ottimizzazione equivalenza per sostituzione trasparenza del riferimento (referencial transparency) x:=f();p(x,x) p(f(),f())? To avoid the need for explicit erasure of unused list structures

10 LISP: struttura dati S-expr : (PLUS A B) espressioni simboliche, perché le foglie sono simboli detti anche atomi perchè privi di struttura ma ci torniamo sopra cfr arrayin FORTRAN, recordin COBOL oggi coesistono naturalmente

11 LISP: struttura dati Alberi binari Proto sintassi astratta (PLUS A B) abbrevia (PLUS. (A. (B. NIL))) struttura a lato rappresenta A+B CAR CDR Cella cons = parola IBM 704 CAR = contents of the addresspart of register CDR = contents of the decrementpart of register

12 LISP: codice Nei progetti iniziali: sintassi concreta MLISP (Meta LISP) o LISP2, per scrivere i programmi Espressione aritmetica da manipolare :(PLUS A B) da calcolare : plus[a;b] S-expr usate come rappresentazione interna ritardata realizzazione del traduttore codifica in S-expr del linguaggio per definirne la semantica Incidente favorevole (insieme all'interpretazione): LISP1.5 è type-less (come il linguaggio macchina) favorisce l auto modifica dei programmi "Syntactic sugar causes cancer of the semicolon." Alan Perlis in realtà ci sono i numeri (interi) Controllo dinamico dei tipi (a tempo d'esecuzione)

13 LISP e concorrenti Linguaggi funzionali vs imperativi (con stato) LISP: ambiente di valutazione delle variabili a-list : Nomi Valori» semantica per riferimento, contrapposta a FORTRAN e COBOL valutazione di una variabile: env o mem» env : Nomi Locazioni» mem : Locazioni Valori semantica per valore degli altri terminologia antica» da History of Programming Languages

14 LISP e concorrenti Altri linguaggi "simbolici" SNOBOL manipolava direttamente stringhe di caratteri "pattern" per individuare i punti da sostituire, back-tracking IPL (sexi) pioneered the concept of list processing albeit in an assembly-language style» (A. Newell, C. Shaw, and H. Simon (Nobel '78))

15 Cose di casa nostra Anni '60: Roma ROMALISP C. Böhm et al: ri-fare per capire per usare: non c'era SourceForge!» non era ovvio portare un sistema di programmazione da una macchina a un'altra Anni '70: Pisa MagmaLISP CM, G. Pacini e F. Turini estensione per non-determinismo

16 Il linguaggio (puro) Primitive di manipolazione S-expr: CONS : S-expr ₓ S-expr S-expr CAR, CDR : S-expr S-expr ATOM : S-expr {T, NIL} EQ : Atom ₓ Atom {T, NIL} Forme: espressioni da valutare speciali: (QUOTE f) (COND (p 1 f 1 )... (p n f n ))

17 Il linguaggio puro (2) Forme generali: (f op f 1... f n ) : applica f op ai valori ottenuti da f 1... f n Definizioni (LAMBDA x f) Dichiarazione (LABEL fn f) : definisce f(x) sostituisce il combinatore Y: : nomina f come fn (ricorsione)

18 Il linguaggio (pragmaticamente impuro) Componente imperativa DEFINE, per le definizioni di funzione PROG, SETQ, per programmi sequenziali RPLACA, RPLACD, per effetti collaterali sulle liste» ridefinizione dei puntatori» incubo teorico

19 Evalquote e Apply (primitive)

20 Apply (2)

21 Eval

22 Un esempio, finalmente! First = car, rest = cdr Non serve label Ricorda qualcosa?

23 Un altro esempio Tests è la lista di coppie del cond Second = cadr

24 L'interprete metacircolare

25 Espressioni condizionali (COND) if p 1 then c 1 elseif... elseif p n then c n endif

26 Scelte in FORTRAN if x<ythen \\21 else \\22 end if \\24 Costrutto di controllo trasposto dal linguaggio di macchina: IF(X-Y)21,22,22 C X-Y< GOTO 24 C X-Y C JOIN 24...

27 Apply pairs aggiunge a env i legami parametri-argomenti

28 Eval

29 Esempio: Wang algorithm......

30 Wang algorithm (2)......

31 LISP e λ-calcolo λ-calcolo formalismo teorico per lo studio della calcolabità equivalente alla Macchina di Turing Universale (A. Church, 1936) paradigma: calcolo di funzioni: calcolo per riduzione (sostituzione testuale): nessuna struttura dati: e.g.: interi codificati (astutamente) come funzioni

32 LISP e λ-calcolo (2) LISP (puro) struttura dati: S-expr simula la sostituzione testuale a-list (association list) ambiente di valutazione: a-list : Nomi Valori Semantica Lips1.5: con interprete (meta-circolare) λ-calcolo: nessuna fino al 1975 (Dana Scott ( 76)) McCarthy: "non ho capito molto del lavoro di Church" "ho preso la notazione per le funzioni"

33 Vera scienza

34 Inserto: il combinatore paradossaley se N= (n=0->1,n*f(n-1)) λf. λn.n assomiglia al fattoriale ((λf. λn.n)?) 3 ((λf. λn.n) (λf. λn.n) ) 3 = (λn. (n=0->1,n*(λf. λn.n (n-1)) )) 3 = 3*(λf. λn.n (n-1)) ci metto (Y λf. λn.n), dove Y = (λg. (λg.g(g g)) (λg.g(g g))) :-(

35 Y F punto fisso di F Y F = (λg.(λg.g(g g)) (λg.g(g g))) F = (λg. F(g g)) (λg. F(g g)) = F( (λg. F(g g)) (λg. F(g g)) ) = F( Y F ) per cui, dato che N = (n=0->1,n*f(n-1)) ((λf. λn.n) (Yλf. λn.n)) 3 3=0->1,3*((Yλf. λn.n) 2) 3*( ((λf. λn.n) (Y λf. λn.n)) 2 ) diventa ma YF = F(YF) e così via...

36 Scherzi della memoria Acknowledgments The inadequacy of the LAMBDA-notation for naming recursive functions was noticed by N. Rochester, and he discovered an alternative to the solution involving label which has been used here.

37 Binding dinamico (def show (lambda () x )) (def try (lambda (x) (show) )) (show) (x)? (try t) (show) [x/t] [x/t](x) t In C ecc, il comportamento di show è univoco: il primo x è indefinito binding statico: le due "x" si riferiscono a due celle diverse In LISP, dipende dal contesto d'invocazione: binding dinamico λz.pz = 2 o 3?

38 Involontario Scoperto da J. Slagle Durante la tesi (integrazione simbolica) (def testr (lambda (x p f u) (cond ((p x) (f x)) ((atom x) (u)) (t (testr (cdr x) p f (lambda () (testr (car x) p f u)))) ) )) Tipico esempio di programmazione funzionale Problema noto come FUNARG(functional argument)

39 La madre di tutte le funzioni higher order (defun map (FUN X) (cond((null X) X) (t(cons (FUN (first X)) (map FUN (rest X> map restituisce la lista dei risultati dell applicazione di fun a ogni elemento di X Alla base del modello MapReduce di Google

40 Esempio (map '(lambda (x) (list x x)) '(CHITTY BANG)) restituisce X è zucchero sintattico per (QUOTE X) ((CHITTY CHITTY) (BANG BANG)) Se usiamo map per definire consall, tale che (consall'beat '(HARVARD YALE)) dia ((BEAT HARVARD) (BEAT YALE))

41 Esercizio (defun consall(x L) (map '(lambda(y)???) L)) (consall 'BEAT '(HARVARD YALE)) dia ((BEAT HARVARD) (BEAT YALE))

42 Cave! (defun consall(x YS) (map '(lambda(y) (list X y)) YS)) dà invece: ((HARVARD YALE) HARVARD) ((YALE) YALE)) perché X è legato a (HARVARD YALE) e non a BEAT: (defun map (FUN X) La X di map maschera quella di consall Cambiare nome è poco generale...

43 La soluzione: chiusure Due nuove forme speciali FUNCTION per marcare le funzioni CLOSURE per conservare l ambiente Si risolve anche il problema delle funzioni come valori proceduralizzazione della conoscenza

44 La soluzione: nuovi problemi? Ambiente: Interprete: lista Compilatore: stack Stack: Funarg : abbastanza bene Funzioni come valori: Havoc Cactus stack

45 La storia continua... J. Moses nel 67 osserva many LISP implementers don t care about the FUNARG problem, i.e. that interpreted and compiled programs can behave differently E più naturale implementare il binding statico in un compilatore che in un interprete... Scheme, un dialetto del LISP sviluppato negli anni settanta, oltre a usare lo statico, abbandona completamente lo stack, e alloca i frame nello heap

46 Le liste di proprietà Avevamo detto: "atomi, perchè senza struttura" In realtà sono "classi statiche"/"record" In LISP 1.5 predefinite, con i selettori PNAME: nome esterno (lista di caratteri) EXPR: definizione di funzione (lambda-expr) SUBR: definizione di funzione (primitiva) TRACE: indicatore di traccia dell'esecuzione APVAL: valore di top-level (S-expr)

47 Le liste di proprietà APVAL: NIL vale NIL, T vale T, F vale T cset[obj;value] permette di definirlo Eval si ridefinisce anche in termini di π : Atom ₓ Atom S-expr

48 Poi... putprop: Atom ₓ S-expr ₓ Atom S-expr apply[putprop;(a V P);...] ha valore V (= identità sul secondo argmento) effetto collaterale: definisce la proprietà P di A Record dinamici selettori definibili a run-time MLISP2 (1973) usa la "dot notation"

49 Garbage-collection Atomi p-list Pila di controllo a-list Lista libera

50 LISP: innovazioni P. Graham, What Made LISP Different, May Conditionals They were invented by McCarthy for LISP: since he was on the Algol committee got conditionals into Algol, whence they spread to most other languages. 2. A function type In LISP, functions are first class objects, they're a data type just like integers, strings, etc, and can be stored in variables, can be passed as arguments, and so on. 3. Recursion Recursion existed as a mathematical concept before LISP of course, but LISP was the first programming language to support it.

51 LISP: innovazioni (2) 4. A new concept of variables In LISP, all variables are effectively pointers. Values are what have types, not variables, and assigning or binding variables means copying pointers, not what they point to. 5. Garbage - collection 6. Programs composed of expressions LISP programs are trees of expressions, each of which returns a value. This is in contrast to Fortran and most succeeding languages, which distinguish between expressions and statements.

52 LISP: innovazioni (3) 7. A symbol type Symbols differ from strings in that you can test equality by comparing a pointer. 8. A notation for code Using trees of symbols 9. The whole language always available There is no real distinction between read -time, compile - time, and runtime. [...] reading at runtime enables programs to communicate using s-expr, an idea recently reinvented as XML.

53 Due culture... When LISP was first invented, all these ideas were far removed from ordinary programming practice, which was dictated largely by the hardware available in the late 1950s. Over time, the default language, embodied in a succession of popular languages, has gradually evolved toward LISP:

54 Compilatore Meglio: generatore di codice La sintassi astratta viene gratis! self-hosting: compila se stesso Conviene una macchina intermedia Lisp-machine Reale, da Symbolics Esercizio: trasformare l interprete in un compilatore

55 Due culture Conditionals 2. A function type 3. Recursion 4. A new concept of variables 5. Garbage collection are now widespread. 6. Programs composed of expressions -is starting to appear in the mainstream 7. A symbol type -Python has a form of this, though there doesn't seem to be any syntax for it. 8. A notation for code 9. The whole language always available - are so far still unique tolisp

56 LISP vs il resto del mondo Though useful to present-day programmers, it's strange to describelisp in terms of its variation from the random expedients other languages adopted. La vitalità del LISP si deve probabilmente alla flessibilità che gli deriva in definitiva dalla sua originaria accidentale type-freeness. Oggi l'interesse verso la manipolazione di programmi, e più in generale di modelli, (metaprogrammazione) riporta in auge quest concetti.

57 Conclusioni Graham dice ancora: That [la flessibilità] was not, probably, how McCarthy thought of it. LISP wasn't designed by to fix the mistakes in Fortran LISP came about more as the byproduct of an attempt to axiomatize computation. Un interesse teorico simile si ha oggi per sistemi di tipi higher order: permettere di manipolare funzioni di funzioni con garanzie tipo quelle fornite dai correnti linguaggi per il prim'ordine.

58 Bibliografia J. McCarthy et al. LISP 1.5 Manual (1963) J. McCarthy. History of LISP. Newell, A. and F.C. Shaw. "Programming the Logic Theory Machine." Feb Proceedings of the Western Joint Computer Conference, pp D.C. Smith, H.J. Enea. MLISP2 (1973)

59 Bibliografia D. S. Scott,"Data types as lattices". LNCS 499, P. Graham. ANSI Common LISP. Prentice-Hall, P. Graham. What Made LISP Different. May J. Moses. The Function of FUNCTION in LISP Or Why the FUNARG Problem Should be Called the Environment Problem. MIT Mem G. Steele. A History of Scheme. SchemeHistory-2006public.pdf