LISP-anteckningar Av Jörgen Sigvardsson

Introduktion till LISP LISP – Del 1 Introduktion till LISP

Agenda LISP? Vanliga programspråkselement

LISP = LISt Processing LISP 1.5 - 1956 MacLisp ~ 1970 InterLisp ~ 1975 Inte längre bara prog. språk Även en komplett miljö (GUI m.m) LISP 1.5 - 1956 Multipla argument Exceptions MacLisp ~ 1970 InterLisp ~ 1975 Lisp Machine ~ 75 LSD? ;-) CommonLisp - 86 Smalltalk (OO!) Lexikalisk scoping Bättre koppling till teori OO ? Scheme - 1975 CLOS – 198?

Syntax Program ::= { Form1 }* Form ::= ’(’ { Form }+ ’)’ | Konstant EG(1) Syntax Program ::= { Form1 }* Form ::= ’(’ { Form }+ ’)’ | Konstant Konstant ::= Lista | Atom Lista ::= ’(’ { Konstant }+ ’)’ Atom ::= Tal | Sträng | ... | Symbol Visa ett exempel på LISP-kod (defun add (x y) (+ x y)) Form = Uttryck! 1 Eng. Form, översätts till Formulär?

Formulär (Eng. Forms) vänster  höger, in  ut (* (+ 1 2) (- 4 3)) = (* 3 (- 4 3)) = (* 3 1) = 3 Alla uttryck normaliseras alltid till ett ”värde” med undantag för några få... (if, cond, etc.) Ge några fler exempel på tavlan. Djupa nästade saker

Värdeformer Cons + Atom = Listor car cdr ? car cdr car cdr car cdr Ø ? EG(2) Värdeformer Cons + Atom = Listor car cdr ? car cdr car cdr car cdr Ø Vad betyder car/cdr? (IBM 704, car = Contents of Address Register, cdr = Contents of Decrement Register) Visa hur (1 2 3) blir i cons-format. Exakt vad är en atom? Visa (1 . 2). Visa () (som för övrigt är en atom...)! Alla typer är antingen en cons (lista) eller en atom. Vektorer (array) är t.ex en atom. ? ? ? ? ?

Typer Standardtyper Egendefinierade typer Heltal, flyttal, bråktal Strängar Arrayer Listor (doh!) Egendefinierade typer Strukturer (C/C++ struct-liknande) Heltal: 1, #B101 (5 dec), #X12 (18 dec), #O20 (16 dec), #5R14 (bas 5! = 9 dec) Flyttal: 1.0, 2e3, 2e-3 Bråktal: 1/3, 4/5, 3/2 (alla operationer på bråktal => bråktal) Strängar: ”hmm” Array: #2A((1 2 3) (4 5 6)) (3 x 2-matris), #1A(1 2 3 4) = [1, 2, 3, 4] = #(1 2 3 4) el. #4(1 2 3 4) (= specialfallet vektor) Listor: ’(1 2 3 4) Struktur: (defstruct point (x 0.0 :type short-float) (y 0.0 :type short-float)) (point-p (make-point :x 1.0 :y 3.3)) = TRUE

Input och Output Två språk Ett input-språk (följer syntax) Ett output-språk (följer egna regler) Förklara här vitsen med ’ – literals En lista i input = ’(a b c) En lista i output = (a b c) (defun f (x) (* x x)) <- input #'(LAMBDA (X) (DECLARE (LAMBDA-NAME F)) (BLOCK F (* X X))) <- output

EG(4) Tilldelning (setf var-name1 value1 var-name2 value2 ... var-namen valuen) Utanför en funktion så deklareras variabeln globalt – en s.k. Special variable. I annat fall påverkar den variabel som ligger i närmsta scopet Returnerar sista värdet (valuen)

Sekvens (prog1 expr1 expr2 ... exprn) (progn expr1 expr2 ... exprn) EG(5) Sekvens (prog1 expr1 expr2 ... exprn) (progn expr1 expr2 ... exprn) Normalt sett exekveras alla uttryck i tur och ordning där det finns ”syntaktiskt” utrymme. Det finns dock specialfall där sådant ”syntaktiskt” utrymme finns. Där är progn trevligt att ha Generellt sett är det alltid det sista värdet i en sekvens som returneras. I Scheme heter progn begin

Predikat Sant: T el. ¬Falskt, Falskt: NIL EG(6) Predikat Sant: T el. ¬Falskt, Falskt: NIL Typtest: typp – predikat för typen typ Ekvivalenstest: eq, eql, equal, =, /= Relationstest: <, >, >=, <=, string<, string> ... Listpredikat: null & endp Logiska predikat: and, or, not T = konstant. NIL = konstant = ’() <- notera tomma listan! consp/listp, (listp x) = (or (eq x ’()) (consp x)) atom, stringp, numberp, rationalp, realp (eq x y) = om x o y är SAMMA symbol, så sant (eq 1 1) => sant (eq ’a ’a) => sant (eq ’b ’a) => sant (eql x y) = (eq x y) eller om x o y är nummer av samma typ, så jfr nummren eller om x o y är tecken, jfr tecknen (equal x y) = (eq x y) om x o y är symboler, (eql x y) om x o y är nummer eller tecken, annas jfr på värdebasis! (equal 1 1.0) => sant! (jfr (eql 1 1.0) => falskt) eql är farlig då den är implementationsberoende! (eql ”str” ”str”) kan bli falskt eller sant beroende på lisp-tolk-implementation! (and form1 form2 ... formn) – form1 && form2 ... && formn (or form1 form2 ... formn) – form1 || form2 ... || formn Om and returnerar icke-NIL, så är det det sista värdet som returneras Om or returnerar icke-NIL så är det det första värdet som returneras

Selektion (if bool-expr then-form else-form) EG(7) Selektion (if bool-expr then-form else-form) (when bool-expr then-form) (unless bool-expr else-form) (cond (test1 then-form1) (test2 then-form2) ... (testn then-formn) (t default-form))

EG(7) Selektion (forts.) (case key-expr (key1 then-form1) (key2 then-form2) ... (keyn then-formn) (otherwise else-form)) Case använder sig av eql-predikatet för att hitta rätt ”slot”

Scoping Dynamisk Lexikalisk VARNING! KAN MEDFÖRA HJÄRNSKADOR! Globalt scope Lokala scopes Funktioner Rita scoping-bilder Förklara därmed dynamisk & lexikalisk scoping Varför är dynamisk scoping skräp -> inte speciellt funktionellt! (Sido-effekter)

EG(8) Lokala scopes (let ((name1 val1) ... (namen valn)) body-expr1 ... body-exprn) (let* ((name1 val1) ... (namen valn)) body-expr1 ... body-exprn) Förklara skillnade på let & let* let = parallel, let* = seriell (let ((x 1) (y x)) (+ x y)) <- ogiltigt! (let* ((x 1) (y x)) (+ x y)) <- giltigt... Nämn Letrec i Scheme (flet i Lisp)

Speciella formulär setf, let, let*, case, cond och några till.. Evalueras olika från vanliga formulär Där vanlig innebär anrop till funktioner Förklara if, when, cond, o.s.v

Funktioner i LISP LISP = Funktioner + Data1 EG(9) Funktioner i LISP LISP = Funktioner + Data1 Funktioner är förstklassiga värden och behöver därmed ej ha namn bundna Rekursion > Iteration Nya tekniker – tail recursion Varför rekursion? Livet blir lättare!2 Funktioner i LISP är förstklassiga värden Kan skickas som parameter Kan returneras som parameter Kan bäddas in i en lista Kan bäddas in i en struktur Kan appliceras Kan skapas dynamiskt! (lambda) Ex: (mapcar #’print ’(1 2 3)) (defun x (compose #’print #’car) I Lisp föredrar man rekursion över iteration. Detta p.g.a LISP’s funktionella natur. Den funktionella paradigmen vill Hellre att man beskriver problemet som en ekvation istället för ett ”recept”. Recept-beskrivningen fungerar helt enkelt inte i den Funktionella världen. Recept: f(x) = x^2 + x – kvadrera först x och lägg sedan till x <- absurt? Ja! Problem: Rekursion = kostsamt Lösning: Svansrekursion! Omskrivning: Svansrekursiv(f) + regler -> Iterativ(f). Omskrivningen görs av kompilatorn/tolken! Varför Rekursion? LIVET BLIR LÄTTARE! Spana in (defun minappend ...)! 1 Ofta i form av listor 2 Se EG(9) minappend t.ex

EG(9) Svansrekursion Definieras av att allt jobb görs på vägen ”ner” i rekursionen Visa exemplet fak och fak2 från EG(9) Gå igenom (fak 4) och (fak2 4)

Operationer? Operationer = Funktioner  Operationer är förstklassiga Operationer existerar inte. Operationer är ”vanliga” funktioner. I och med att operationer är funktioner, så kan man använda dessa där en funktion förväntas Ex: (apply #’+ ’(1 2 3))

LISP – Del 2 Fortsättningen

Agenda Standardtyper Egendefinierade typer Funktioner ADT’er Listor ADT’er m.h.a listor I/O & Iteration

”4+¥ i top”-typerna i LISP NUMBER ARRAY STRING CHARACTER Egendefinierade typer (defstruct)

Typen NUMBER Urbastyp för alla aritmetiska typer Alla operationer man kan förvänta sig finns (+, -, sqrt, abs, max, etc.) Operationerna är polymorfiska! Number Complex Real Polymorphism och typ/klass-hierarkier ett nytt concept? Knappast... Integer Rational

Typen ARRAY Operationer: Flerdimensionella Direktåtkomst EG(10) Typen ARRAY Flerdimensionella Om 1 dimension  Vektor Om 2 dimensioner  Matris Direktåtkomst Fullt polymorfiska Operationer: Konstruktörer make-array Inspektörer array-dimension array-rank array-total-size aref Muterare adjust-array Predikat array-in-bounds-p Arrayer beteer sig mycket likt arrayer i C/C++ Dock kan man ”justera” om arrayer

Typen STRING Operationer: Subtyp till ARRAY EG(11) Typen STRING Subtyp till ARRAY String har några fler operationer Ekvivalenspredikat samt relationspredikat (se EG(6)) Operationer: Konstruktörer make-string Inspektörer length char + alla array-operationer! Precis som i C så är en sträng ett specialfall av en character array. Dock finns inget \0-tecken i Lisp. De flesta operationer som finns för arrayer har ”döpts” om för strängar så att de känns mer naturliga. Aref  char t.ex. ARRAY STRING

Typen CHARACTER Utgör byggstenar för strängar Syntax: #\<tecken> Operationer: Predikat char= char/= char< char> char<= char>=

Egna typer - defstruct Konstruktorer Typ-predikat Inspektörer ”Nästan-arv” Defstruct likt struct i C/C++ Inspektörer returnerar referenser!  setf fungerar på dessa Man kan bestämma namnen för konstruktörer, typ-predikat o inspektörer utifall man inte gillar standardnamnen Man kan inkludera andra typdefinitioner i en typ. Detta är subtypning och gör att typerna är polymorfa. Dock blir inspektörerna ej polymorfa  detta är inte äkta ”OO-arv”.

Funktioner med namn (defun name (parameters) form) EG(13) Funktioner med namn (defun name (parameters) form) form bäddas in i ett eget scope scope innehåller: parametrar + namn + namn omslutande scope Defun definierar en funktion som får ett namn bundet till det globala scopet Defun-namn krockar ej med variabel-namn. &rest <- smart funktion! &optional <- lite farlig.. Se exempel i EG(13) &key <- säkrare än &optional. Se EG(13)

Funktioner utan namn (lambda (parametrar) form) EG(14) Funktioner utan namn (lambda (parametrar) form) Samma scopingregler som för en defun* Lambda är en special form (funktion) vars returvärde är en funktion som tar parametrar och är form Att skriva (defun f (x) (+ x x)) är att binda funktionsnamnet f till formen (lambda (x) (+ x x)) (Funktionsnamn är speciella namn då de (tyvärr) binds i en separat symboltabell än den som variabler binds i – Detta gäller dock ej i Scheme) (Funktionell dubbelmoral kallas detta för!) Implikationer? Funktionstransparens: Man anropar någon funktion m.h.a av något namn. Vilken funktion det är, framgår inte av namnet. Kan jämföras med pekare. Resultat: Extremt flexibla program Funktioner som mapcar kan användas i kombination med lambda – temporära funktioner Komposition av funktioner * Som du kanske redan förstått så har defun ärvt scopingreglerna från lambda!

Listor Lista definition 2 Lista definition 1 List ::= Head Tail Head ::= List | Atom Tail ::= List | NIL Lista definition 1 List ::= Cons | NIL Cons ::= (Cons | Atom){2} En lista är en cons-cell eller nil En cons-cell är två värden ordnade. Dessa värden benämns ofta som CAR och CDR. Dessa värden kan vara atomer eller nya cons-celler. I fallet lista brukar man prata om CAR som listans huvud, och CDR som listans svans. Då tänker man på en lista som ett huvud + svans. Där svans är en lista. Strukturen och operationer är inte så underliga : troligtvis mycket likt det som togs upp på DSA car cdr car cdr car cdr Ø 1 2 3

Listor & Operationer Konstruktörer Inspektörer Predikat ”Misc” EG(15) Listor & Operationer Konstruktörer cons, list, append, mapcar Inspektörer car, cdr, cadr, caddr, nthcdr Predikat endp, null, listp, consp (se EG(6)) ”Misc” apply

Associationslistor AssocLista ::= ({(key value+)}*) EG(16) Är i princip en lista av associationer. Key måste narturligtvis vara unik. Är ADT’n Dictionary (som ofta implementeras som Hash-tabell)

EG(17) ADT’er defstruct bst, stack, avl, graph, etc. Likt C/C++

Listor + Regler = ADT (bst ...) (graph ...) (stack ...) (queue ...) Symboler + listor -> ADT Fungerar ypperligt istället för att använda ”flashiga” saker som defstruct. Detta kan användas för att bygga ett OO-system. En annan metod är att titta på CLOS ;-) så slipper man att ”bränna egna objekt”

EG(19) Iteration (do ({(var initval next)}*) ([end-cond [end-value]] | NIL) body-form) (loop body-form) Naturligt vid I/O-operationer Do ger nytt scope, men ej loop. Do är lite annorlunda mot t.ex for i C/C++ då loop-invarianten beskriver när loopen avbryter istället för att beskriva när den skall fortsätta. I Lisp: Iteration är mer svårjobbat än rekursion. Men det är mer naturligt vid I/O-operationer. Filer är högst iterativa konstruktioner. Yadda yadda.

EG(20) I/O – Del 1 (open filename [:direction {:output, :input, :io, :probe}] [:element-type {:default, typnamn}] [:if-exists { :error, :new-version, :rename, :rename-and-delete, :overwrite, :append, :supersede, NIL}] [:if-does-not-exist {:error, :create, NIL}]) (close stream) Open: filnamn -> stream Close: stream -> NIL Filer bygger på ”strömmar” precis som fstream/iostream i C++ och open/read/write/close i UNIX (sockets, filer, FIFO’s <- samma interface).

I/O – Del 2 (read-type [input-stream [eof-error-p [eof-value]]] EG(20) I/O – Del 2 (read-type [input-stream [eof-error-p [eof-value]]] (write-type char [output-stream]) Input-stream: Det man vill läsa från. Om nil så från standard input Eof-error-p: predikat för att avgöra om end of file är ett logiskt fel eller ej Eof-value: vilket värde skall symbolisera EOF? ’EOF är en kandidat.. :) Dessa funktioner finns för alla fördefinierade typer. Det finns även högnivå-funktioner som ”write-sequence” som skriver flera block på en gång. Kan jämföras med fwrite() i C.

I/O – Del 3 (with-open-file (stream-var open-args*) body-form) EG(20) with-open-file skapar ett nytt scope. När programkontrollen förflyttas ut (utåt) från scopet, stängs filen automatiskt. * open-args är filnamn + alla flaggor som ges till open

Summering Du har lärt dig Syntax Grundkonstruktioner såsom if, setf, defun, etc. Mer avancerade konstruktioner lambda, mapcar, etc. Listor – LISP’s hörnsten ADT’er – strukturtyper såväl som listbaserade typer

Referenser History of Lisp Historien om CAR & CDR http://www-formal.stanford.edu/jmc/history/lisp/lisp.html Historien om CAR & CDR http://home.planet.nl/~faase009/HaCAR_CDR.html GCL (GNU Common Lisp) ftp://ftp.gnu.org/gnu/ CLISP (An ANSI Common Lisp) (Finns för många platformar) http://clisp.sourceforge.net/ Donalds Lisp-bibliotek http://www.cse.kau.se/~donald/pub_plang/ Xanalys Common Lisp (Bra implementation för Windows) http://www.xanalys.com/ The Association of Lisp Users http://www.lisp.org/ Schemers.org (Scheme Lisp) http://www.schemers.org/ Haskell – A Purely Functional Language http://www.haskell.org/