Transcript LISP – Del 1

LISP-anteckningar
Av Jörgen Sigvardsson
LISP – Del 1
Introduktion till LISP
Agenda


LISP?
Vanliga programspråkselement
LISP = LISt Processing
Multipla argument
Exceptions
LISP 1.5 - 1956
Inte längre bara prog. språk
Även en komplett miljö (GUI m.m)
MacLisp ~ 1970
InterLisp ~ 1975
Lisp Machine ~ 75
LSD? ;-)
CommonLisp - 86
Lexikalisk scoping
Bättre koppling till teori
Smalltalk
(OO!)
OO
?
Scheme - 1975
CLOS – 198?
EG(1)
Syntax





Program ::= { Form1 }*
Form ::= ’(’ { Form }+ ’)’ | Konstant
Konstant ::= Lista | Atom
Lista ::= ’(’ { Konstant }+ ’)’
Atom ::= Tal | Sträng | ... | Symbol
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.)
EG(2)
Värdeformer
Cons
+ Atom = Listor
car cdr
?
?
?
car cdr
?
car cdr
?
car cdr
?
Ø
EG(3)
Typer

Standardtyper





Heltal, flyttal, bråktal
Strängar
Arrayer
Listor (doh!)
Egendefinierade typer

Strukturer (C/C++ struct-liknande)
Input och Output

Två språk


Ett input-språk (följer syntax)
Ett output-språk (följer egna regler)
EG(4)
Tilldelning

(setf var-name1 value1
var-name2 value2
...
var-namen valuen)
EG(5)
Sekvens


(prog1 expr1 expr2 ... exprn)
(progn expr1 expr2 ... exprn)
I Scheme heter progn begin
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
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
(key2
...
(keyn
(otherwise
then-form1)
then-form2)
then-formn)
else-form))
Scoping

Dynamisk


VARNING! KAN MEDFÖRA
HJÄRNSKADOR!
Lexikalisk



Globalt scope
Lokala scopes
Funktioner
EG(8)
Lokala scopes

(let
((name1 val1) ... (namen valn))
body-expr1
...

body-exprn)
(let* ((name1 val1) ... (namen valn))
body-expr1
...
body-exprn)
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
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
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
Operationer?

Operationer = Funktioner

 Operationer är förstklassiga
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
Integer
Rational
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
EG(11)
Typen STRING



Subtyp till ARRAY
String har några fler
operationer
Ekvivalenspredikat
samt relationspredikat
(se EG(6))
ARRAY
STRING

•
•
•
Operationer:
Konstruktörer
•
make-string
Inspektörer
•
length
•
char
+ alla array-operationer!
Typen CHARACTER


Utgör byggstenar
för strängar
Syntax:
#\<tecken>

•
Operationer:
Predikat
•
char=
•
char/=
•
char<
•
char>
•
char<=
•
char>=
EG(12)
Egna typer - defstruct




Konstruktorer
Typ-predikat
Inspektörer
”Nästan-arv”
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
EG(14)
Funktioner utan namn

(lambda (parametrar) form)

*
Samma scopingregler som för en defun*
Som du kanske redan förstått så har defun ärvt scopingreglerna från lambda!
Listor

Lista definition 2
Lista definition 1



List ::= Cons | NIL
Cons ::= (Cons | Atom){2}
List ::= Head Tail

Head ::= List | Atom

Tail ::= List | NIL

car cdr
1
car cdr
2
car cdr
3
Ø
EG(15)
Listor & Operationer

Konstruktörer


Inspektörer


car, cdr, cadr, caddr, nthcdr
Predikat


cons, list, append, mapcar
endp, null, listp, consp (se EG(6))
”Misc”

apply
EG(16)
Associationslistor

AssocLista ::= ({(key value+)}*)
EG(17)
ADT’er

defstruct


bst, stack, avl, graph, etc.
Likt C/C++
EG(18)
Listor + Regler = ADT




(bst ...)
(graph ...)
(stack ...)
(queue ...)
EG(19)
Iteration



(do ({(var initval next)}*)
([end-cond [end-value]] | NIL)
body-form)
(loop body-form)
Naturligt vid I/O-operationer
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)
EG(20)
I/O – Del 2


(read-type
[input-stream [eof-error-p [eof-value]]]
(write-type char [output-stream])
EG(20)
I/O – Del 3

(with-open-file (stream-var open-args*)
body-form)
*
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.lisp.org/
Schemers.org (Scheme Lisp)


http://www.xanalys.com/
The Association of Lisp Users


http://www.cse.kau.se/~donald/pub_plang/
Xanalys Common Lisp (Bra implementation för Windows)


http://clisp.sourceforge.net/
Donalds Lisp-bibliotek


ftp://ftp.gnu.org/gnu/
CLISP (An ANSI Common Lisp) (Finns för många platformar)


http://home.planet.nl/~faase009/HaCAR_CDR.html
GCL (GNU Common Lisp)


http://www-formal.stanford.edu/jmc/history/lisp/lisp.html
http://www.schemers.org/
Haskell – A Purely Functional Language

http://www.haskell.org/