A Lisp programozási nyelv

Összefoglalás

1
Áttekintés

Bevezetés

Függvények

Gyakorlatok

2
A Lisp nyelv jellegzetességei
1. Belső adattípusai a listák: könnyen felépíthetők, és kezelhetők
2. Dinamikus kötést használ
3. A program maga is egy adat
4. Az interpretált nyelvek osztályába tartozik
5. Deklaratív nyelv
 A lényeg azon van, hogy MIT modellezünk, nem pedig hogyan!!!
6. Funkcionális nyelv
 A szintaxis és a szemantika a rekurzív függvényeken alapszik
(belső függvények, ill. felhasználó által értelmezettek).
 A szimbolikus adatokat könnyen kezeli (pl. a C++ nyelvhez
képest).
7. Népszerűsége a MI körében
 Széles körben alkalmazzák a MI problémáinak modellezésére.
 Eredetileg szimbolikus számítások elvégzésére tervezték
 Ideális nyelv prototípus rendszerek felépítésére és tesztelésére.

3
Informális szintaxis
 Atom: karaktersorozat. Ezt alkothatják
betűk, számok, egyéb karakterek (* + - / @
$ % ^ & _ < >).
 Példa: A, *globális*, T, Lali-tanul6na, -15,
 Egy lista atomok vagy újabb listák sorozata
zárojelek között felsorolva (rekurzív
struktúra!!!).
 Példa: (1 2 3 4), (A (B C) D (E (F)))
 S-kifejezés -atomok és listák együttese.
 Példa: (A (B 3) (C) ( ( ) ) )

4
Formális szintaxis

 <S-kifejezés> ::= <atom> | <lista>

 <atom> ::= <szám> | <azonosító>
 <lista> ::= ( <S-kifejezések> )
 <S-kifejezések > ::= <üres lista>
| <S- kifejezések > <S- kifejezés>
 <szám> ::= <számjegy> | <szám> <számjegy>
 <azonosító> ::= nyomtatható karakterek
fűzére, zárójelek nélkül
5
T és NIL

 NIL az üres lista neve

 Teszteléskor a NIL jelentése ,,hamis’’
 A T általában az ,,igaz’’ értéket
jelenti, de…
 …bármi, ami nem NIL az ,,igaz’’
 NIL-> atom is és lista is egyben!!!

6
A listák belső ábrázolása

lista1 = (nem mind arany ami fénylik)

mind arany fénylik

nem
volt igaz ami elhangzott

lista2 = (nem volt igaz ami elhangzott)

7
Függvényhívások és adatok
 Bármely függvényhívás egy lista:
 a lista első eleme a függvény neve
 a többi elemek az argumentumok
 Példa: (F A B)meghívja az F függvényt az A
és B argumentumokkal
 Az adatok atomok vagy listák
 Példa: (F A B) egy háromelemű lista
 Megjegyzés: A program maga is adatként
kezelhető!!!

8
Olvasás-értékelés-kiírás
 Interaktív környezet
 A felhasználó S-kifejezéseket vezet be.
 A LISP az értelmezőprogrammal kiírja a
képernyőre az eredményt.
 Kiértékelési szabályok
 Atom: értéke saját maga (hibaüzenet, ha
nem kötött!)
 Lista: a LISP úgy értékeli ki, mint egy
függvényt, vagyis kötelező módon
függvénydefiníció kell legyen az első eleme
(különben hibaüzenet!), majd a lista többi
elemét az adott függvény argumentumainak
tekinti és alkalmazza rájuk a definíciót.
9
A kiértékelés megakadályozása

 Minden betűadat elé aposztróf jár

(atomok elé is!)
 (QUOTE (F A B)) az (F A B) listát jelenti
 A QUOTE egy sajátos forma (lásd később)
 Egy sajátos forma argumentumai nem úgy
értékelődnek ki, mint egy függvényé.
 '(F A B) - rövidebb írásmód
 ‘(+ 4 6)  (+ 4 6)

10
Áttekintés

Bevezetés

Függvények

Gyakorlatok

11
Elemi beépített függvények
 CAR (v. FIRST) - a lista fejét adja vissza
 CDR (v. REST) - a lista farkát téríti vissza (a
fej nélküli listát!)
 CONS - egy új fejet tesz be a listába
 EQ - atomok egyenlősége
 EQUAL - két S-kifejezés egyenlősége
 ATOM - leteszteli hogy az argumentuma
atom-e
 NUMBERP - leellenőrzi, hogy argumentuma
szám-e
12
Más hasznos függvény

 (NULL S) - S üres lista?

 (LISTP S) - S lista?
 LIST - listát hoz létre a kiértékelt
argumentumaiból
 (LIST 'A '(B C) 'D)  (A (B C) D)
 (LIST (CDR '(A B)) 'C)  ((B) C)
 APPEND - összetesz két listát
 (APPEND '(A B) '((X) Y) )  (A B (X) Y)

13
CAR (FIRST)

 Egy lista CAR-ja az első objektum a

listában
ha L értéke akkor (CAR L)
(A B C) A
( (X Y) Z) (X Y)
(()()) ()
() NIL
14
CDR (REST)

 Egy lista CDR-je az a lista(!!!) ami

megmarad, ha elhagyjuk a CAR-ját.
ha L értéke akkor (CDR L)
(A B C) (B C)
( (X Y) Z) (Z)
(X) ()
(()()) (())
15
CONS
 CONS két argumentuma van:
 Első: bármely S-kifejezés lehet
 Második: lista kell legyen (különben
pontozott párt kapunk)
 Az eredmény egy új lista amely CAR-ja
az első argumentum, CDR-e pedig a
második.

(CONS ‘A ‘( B C ))  ( A B C )

16
 CONS példák

 CONS tehát összeteszi azt amit a CAR

és a CDR külön választ.
L (CAR L) (CDR L) (CONS (CAR L) (CDR L))
(A B C) A (B C) (A B C)

( (X Y) Z) (X Y) (Z) ( (X Y) Z)
(X) X () (X)

(()()) () (()) (()())

17
Pontozott párok

 Ha a CONS második argumentuma

atom...
 ...pontozott párt kapunk
 Ha a CONS argumentumai A és B
akkor az eredmény (A . B)

18
EQ

 EQ -két atom egyenlőségének

megvizsgálására használjuk
 Listákon nem működik
 Mint minden predikátum, az EQ vagy
NIL-t ad eredményül, vagy bármi
mást, ami nem NIL

19
EQUAL

 EQUAL-megvizsgálja, hogy két S-

kifejezés egyenlő-e
 Atomokra és listákra is
értelmezett
 Mint minden predikátum, az
EQUAL vagy NIL-t ad
eredményül, vagy bármi mást,
ami nem NIL

20
ATOM

 ATOM - argumentuma bármilyen S-

kifejezés lehet
 Visszatérített értéke ,,igaz’’ ha az
argumentum egy atom
 Mint minden predikátum, az ATOM
vagy NIL-t ad eredményül, vagy
bármi mást, ami nem NIL

21
IF

 IF – egyszerű feltétel-vezérlő szerkezet

 Formája:
(IF feltétel akkor-rész különben-rész)
Megj.: feltétel, akkor-rész, különben-rész,
mind S-kifejezések
 Argumentumai sajátos módon értékelődnek
ki!
 Az IF nem függvény, hanem sajátos forma.

22
COND
 COND - az összetett
if...then...elseif...then...elseif...then...
vezérlő-szerkezetet valósítja meg.
 Argumentumai tetszőleges számú,
kételemű listák, a feltételekkel és
tevékenységekkel.
 A függvény argumentumai sajátos
módon értékelődnek ki.
 A COND is egy sajátos forma.
23
A COND alakja

(COND
(feltétel1 tevékenység1 )
(feltétel2 tevékenység2 )
...
(T tevékenységN) )

24
 A sajátos formákról

 Egy sajátos forma (rendhagyó művelet)

olyan, mint egy függvény, de csak
azokat az argu-mentumokat értekeli ki,
amelyek szükségesek.
 IF, COND, QUOTE és a DEFUN sajátos
formák.
 Mi magunk is értelmezhetünk sajátos
formákat (…nem fogunk …).

25
Más hasznos függvény/1.
 (LENGTH L) egy L lista hosszát adja
meg.
 (LENGTH ‘((1 2) 3 (1 (4 (5)))))  3
 (RANDOM N) , ahol N egy egész, egy 0
és N közötti véletlen egészet ad.
 (AND e1 e2 ... eN)-logikai és. Az első NIL-
nél megáll a kiértékelésben.
 (OR e1 e2 ... eN)- logikai vagy. Az első
nem-NIL-ig értékel.
 (NOT e) – logikai tagadás.
26
Más hasznos függvény/forma 2.
 (SETQ s f)- f értékét s-hez köti.
 Csak f-et értékeli ki.
 (SET h f)-f értékét h-hoz köti.
 Mindkét argumentum kiértékelődik.
 (SETF h f)- A SET általánosítása:
mikor h egy szimbólum, úgy
viselkedik, mint a SETQ, különben
mint a SET.
27
Példák a változók megkötésére
 SET és SETQ
(setq x 1)  1 ;;; x felveszi az 1 értéket
(set a 2)  ERROR!! ;;; a NEM értelmezett
(set ‘a 2)  2 ;;; az a szimbólumhoz 2 értéket rendel
(+ a x)  3
(setq l ‘(x y z))  (x y z)
(set (car l) g)  g
l  (g y z)
 SETF
(setf x 1)  1
(setf a 2)  2
(+ a x)  3
(setf l ‘(x y z))  (x y z)
(setf (car l) g)  g
l  (g y z)

28
Saját függvények értelmezése

 (DEFUN függvény_név paraméter_lista

függvény_törzs )
 Példa: Az alább értelmezett függvény
leellenőrzi, hogy az argumentuma üres
lista-e?
(DEFUN NULL (X)
(COND
(X NIL)
(T T)))

29
Tanácsok függvények írásához
 Míg triviális a függvény, próbáljunk a COND
sajátos formával dolgozni.
 Előbb az egyszerűbb esetekkel
foglalkozzunk .
 Kerüljük, hogy több, mint egy alapesetünk
legyen.
 Az alapeset általában az üres listát teszteli a
NULL függvénnyel.
 Tégy valamit a CAR-ral és utána használd a
CDR-t.

30
Áttekintés

Bevezetés

Függvények

Gyakorlatok

31
Egyszerűbb példák

 (DEFUN NÉGYZET (X) ;adott szám négyzete

(* X X))

 (DEFUN ÁTFOGÓ (X Y) ;az átfogó hossza

(SQRT (+ (NÉGYZET X) (NÉGYZET Y))))

 (DEFUN ABSZOLÚT-ÉRTÉK (X) ;modulusz

(IF (< X 0) (- X) X))

32
Rekurzió

 Sok nyelvben a ciklus jelenti az iteráció

alapját
 Lispben a rekurzió alap módszer
 Egy rekurzív függvény három fő részből áll:
 egy eredményből, amely az argumentum egy
részére vonatkozik
 ugyanannak a függvénynek az alkalmazásából,
az argumentum többi részére alkalmazva
 egy megállási feltételből, amikor már nincs az
argumentumnak megmaradt része

33
 Első példa a rekurzióra

(DEFUN HATVANY (X Y)
(COND ((= Y 0) 1)
(T (* X (HATVANY X (- Y 1))))))

34
A MEMBER értelmezése

 Megvizsgálja, hogy egy atom benne

van egy adott atomokat tartalmazó
listában vagy sem.
 (DEFUN MEMBER (A L)
(COND
((NULL L) NIL)
((EQ A (CAR L)) T)
(T (MEMBER A (CDR L)))))
 A MEMBER beépített függvény.

35
Feladat: EGYESIT
 Értelmezzünk egy függvényt két
halmaz egyesítésére.
 Példa: (EGYESIT ‘(A B C) ‘(B C D E)(A B
C D E)
 A rekurzív definíció:
(EGYESIT x y) = ha x első eleme benne van y-ban
akkor (EGYESIT (REST x) y)
különben összetesz (first x) (EGYESIT
(REST x) y)

36
Megoldás: EGYESIT

(DEFUN EGYESIT (H1 H2)

(COND
((NULL H1) H2)
((MEMBER (CAR H1) H2)
(EGYESIT (CDR H1) H2) )
(T (CONS (CAR H1)
(EGYESIT (CDR H1) H2) )) ) )

37
Halmazok metszete

(DEFUN METSZ (X Y)
(COND ((NULL X) NIL)
((MEMBER (FIRST X) Y)
(CONS (FIRST X)
(METSZ (REST X) Y)))
(T (METSZ (REST X) Y))))

38
Halmazok különbsége

(DEFUN KÜLÖNBSÉG (X Y)
(COND ((NULL X) NIL)
((MEMBER (FIRST X) Y)
(KÜLÖNBSÉG (REST X) Y))
(T (CONS (FIRST X)
(KÜLÖNBSÉG (REST X) Y)))))

39
Az EQUAL függvény értelmezése

(DEFUN EQUAL (X Y)
(COND ((NUMBERP X) (= X Y))
((ATOM X) (EQ X Y))
((ATOM Y) NIL)
((EQUAL (CAR X) (CAR Y))
(EQUAL (CDR X) (CDR Y)))))

40
Listákat feldolgozó példák

(DEFUN UJ-MEMBER (X L)
(COND ((ATOM L) NIL)
((EQUAL X (CAR L)) T)
(T (UJ-MEMBER X (CDR L))))

(DEFUN UJ-APPEND (L1 L2)

(IF (NULL L1)
L2
(CONS (CAR L1) (UJ-APPEND (CDR L1) L2))))

41
 Variációk a REVERSE függvényre

;; ezek mindegyike O(n^2) cons műveletet igényel

(DEFUN REVERSE (L)
(IF (NULL L)
NIL
(APPEND (REVERSE (CDR L)) (LIST (CAR L)))))

(DEFUN REVERSE (L)

(AND L (APPEND (REVERSE (CDR L)) (LIST (CAR
L)))))
42
 Gyűjtőváltozó módszere
;; ez a farokrekurziós program O(n) cons mű-
veletet vesz igénybe
(DEFUN REVERSE (L) (REVERSE1 L NIL)

(DEFUN REVERSE1 (L GYUJTO)

(IF (NULL L) GYUJTO
(REVERSE1 (CDR L)
(CONS (CAR L) GYUJTO))))
43
Lapít I

(DEFUN LAPIT (L)

(COND ((NULL L) NIL) ; üres lista
((ATOM (CAR L)) ; ha atom, átlepi és a
; végét lapítja ki
(CONS (CAR L) (LAPIT (CDR L))))
; különben a fejet is lapítja, majd az
; append-del egyesíti egy listában
(T (APPEND (LAPIT (CAR L))
(LAPIT (CDR L))))))

44
 Lapít II
;; ez a változat kikerüli az APPEND használatát,
;; amely költséges.
(DEFUN LAPIT (L) (LAPIT1 L NIL))

(DEFUN LAPIT1 (L GYŰJTŐV)

(COND ((NULL L) GYŰJTŐV) ; már összegyűjtöttük
((ATOM L) ; az első atomot betesszük
; a gyűjtőváltozóba
(CONS L GYŰJTŐV))
(T (LAPIT1 (CAR L) (LAPIT1 (CDR L) GYŰJTŐV)))
45
Helyi változók: LET és LET*

 Új változók létrehozása
 LET: párhuzamos értékadás, helyi kötés
 LET*: szekvenciális értékadás
 LET alakja:
(LET ((valtozó1 érték1) ... (változóN
értékN))
forma1
…
formaM)

46
Helyi változók - LET
 Írjunk függvényt ax2+bx+c=0 megoldására.
 (DEFUN GYOK1 (A B C)
(SETQ TEMP (SQRT (- (* B B) (* 4 A C))))
(LIST (/ (+ (- B) TEMP) (* 2 A))
(/ (- (- B) TEMP) (* 2 A))))
 (GYOK1 1 2 1)  (-1.0 -1.0)
 TEMP  0.0
 Helyi változó deklarálása LET-tel
 (DEFUN GYOK2 (A B C)
(LET (TEMP)
(SETQ TEMP (SQRT (- (* B B) (* 4 A C))))
(LIST (/ (+ (- B) TEMP) (* 2 A))
(/ (- (- B) TEMP) (* 2 A)))))

47
 Helyi változók - LET

 Ha az értékeket a helyi változóhoz kötjük:

(DEFUN GYOK3 (A B C)
(LET ((TEMP (SQRT (- (* B B) (* 4 A C))))
((NEVEZO (*2 A)))
(LIST (/ (+ (- B) TEMP) NEVEZO )
(/ (- (- B) TEMP) NEVEZO ))))

48
Farokrekurzió

(DEFUN SZLISTA (X)

(COND ((= (LENGTH X) 0) 1)
(T (* (CAR X) (SZLISTA (CDR X))))))

49
Egyszer- illetve kétszer tesztelő
farokrekurzió
 (DEFUN MPLANP (X) ;mind páratlan
(COND ((NULL X) NIL)
((ODDP (FIRST X)) T)
((T (MPLAN (REST X))))
 (DEFUN ELSO-ATOM (X)
(COND ((ATOM X) X)
((T (ELSO-ATOM (FIRST X))))
 (DEFUN SZAMOL (X) ;mit is???
(COND ((NULL X) 0)
(T (+ 1 (SZAMOL (REST X))))))

50
Több feltételhez kötés...

(DEFUN SZIMB-KIVESZ (X)

(COND ((NULL X) NIL)
((SYMBOLP (FIRST X))
(CONS (FIRST X)
(SZIMB-KIVESZ (REST X))))
(T (SZIMB-KIVESZ (REST X)))))

51
Többszörös rekurzió
(DEFUN FIB (N)
(COND (EQUAL N 0) 1)
(EQUAL N 1) 1)
(T (+ (FIB (- N 1))
(FIB (- N 2))))))
(DEFUN SZAM-KERES (X)
(COND ((NUMBERP X) X)
((ATOM X) NIL)
(T (OR (SZAM-KERES (CAR X))
(SZAM-KERES (CDR X))))))

52
 Farekurzió (fej-farok)

(DEFUN ATOMSZAM (LIST)

(COND ((NULL LIST) 0)
((ATOM LIST) 1)
(T (+ (ATOMSZAM (CAR LIST))
(ATOMSZAM (CDR LIST))))
))

53
 Feladat: VEKTORÖSSZEG
 (VEKTÖSSZ X Y) - argumentumai listák,
összeadja a megfelelő helyen levő
számokat a listában.
 Példa: (VEKTÖSSZ ‘(3 6 9 10 4) ‘(8 5 2)) 
(11 11 11 10 4)

 (DEFUN VEKTÖSSZ (X Y)
(COND
((NULL X) Y)
((NULL Y) X)
(T (COND (+ (CAR X) (CAR Y)
(VEKTÖSSZ (CDR X) (CDR Y))))))
54
 Függvénytípusok
 A tár tartalmát érintetlenül hagyó függvények, vagyis
mellékhatással nem rendelkezők
(pl. CAR, CDR, EQ, EQUAL)
 Új cellákat lefoglaló függvények, amelyek a meglévők
tartalmát érintetlenül hagyják
(pl. CONS, LIST, APPEND)
 Atomok értékmutatóját megváltoztató függvények
(pl. SETQ)
 Rombolóak vagy rejtett értékadó függvények: az
atomok értékmutatóját nem változtaják meg, de a
listaszerkezetek mutatójának megváltoztatásával
megváltoztathatják egyes atomok értékét
(pl. NCONC, RPLACA, RPLACD, DELETE)

55
Magasabbrendű függvények

 Funkcionál (f): olyan függvény, amely

valamely argumentuma függvény.
 APPLY(f l) – az első paraméterként
megadott függvényt "alkalmazza" a további
paraméterein (listában adjuk meg!)
 (APPLY #’CONS ’(A B)  (A . B)
 FUNCALL(f ... f) – akárhány argumentumú
alkalmazó függvény
 (FUNCALL #’CONS ’A ’B)  (A . B)

56
Magasabbrendű függvények

 MAP függvények:
 úgynevezett listabejáró függvények
 a Lisp nyelv fontos eszközei
 jellegzetességük, hogy rekurzív módon
bejárnak egy listát, amely a második
argumentumuk, és minden megvizsgált
listarészletre alkalmaznak egy függvényt
(ez az első argumentumuk).
 pl. MAPCAR, MAPLIST, MAPCAN, MAPCON

57
MAPCAR

 A MAPCAR az első paraméterként megadott

függvényt végrehajtja a további paraméte-
renként megadott listák első elemein, majd
a második elemeken, és így tovább. Ha egy
lista véget ér, a kiértékelés befejeződik. A
MAPCAR visszatérési értéke az így kapott
lista.
 (MAPCAR #'+ '(1 2 3) '(10 20 30 40) '(100 200
300))(111 222 333)
 >(MAPCAR ‘LIST '(1 2 3) '(a b c))((1 a)(2 b)(3 c))

58
A MAPCAR definíciója és alkalmazása
(DEFUN MAPCAR (F L)
(IF (NULL L) NIL
(CONS (APPLY F (LIST (CAR L)))
(MAPCAR F (CDR L)))))

(DEFUN ATOMSZÁM (X) ; minden szinten!

(COND ((NULL X) 0)
((ATOM X) 1)
(T (APPLY ‘+ (MAPCAR ‘ATOMSZÁM X)))))
; a MAPCAR az APPLY argumentumaként szereplő
; függvényszámára argumentumlistát állít össze
Lásd a TRACE függvényt, ha X=(1 (2 4) (1 (3 5)) 6)!!!

59
 A MAPCAR-t mellőzve...

;szintén minden szinten megszámolja az atomokat

(DEFUN ATOMSZÁM (S)

(COND ((NULL S) 0)
((ATOM S) 1)
(T (+ (ATOMSZÁM (CAR S))
(ATOMSZÁM (CDR S))))))

60
Újabb alkalmazás a MAPCAR-ra
 Mit csinál az alábbi függvény?
(DEFUN MICSI (L)
(IF (ATOM L) 0 (MAX (LENGTH L) (APPLY
‘MAX (MAPCAR ‘MICSI L))))))

 Próbáld ki a sejtésed az alábbi példán:

(MICSI '(1 (2 4) (1 (1 2 3 4 5)) 6))???
 Milyen névvel illetnéd a függvényt?
61
Példák funkcionálokra

(DEFUN MÉLY (LISTA)

(COND ((NULL LISTA) 0)
((ATOM LISTA) 0)
(T (MAX (1+ (MÉLY (CAR LISTA)))
(MÉLY (CDR LISTA))))))

(DEFUN MÉLY2 (LISTA)

(COND ((NOT (LISTP LISTA)) 0)
(T (1+ (MAX (MAPCAR (FUNCTION MÉLY2)
LISTA))))))

62
 LAMBDA-kalkulus
 Egy függvény értelmezésekor a definícióbeli
függvénynév-szimbólum úgynevezett lambdakifejezés
formájában tárolódik.
Általános alakja: (LAMBDA l f1 f2 ... fm)
 A LAMBDA nem függvény, hanem szimbólum, a
lambdakifejezés első eleme, ami jelzi az
értelmezőprogramnak, hogy egy névtelen függvény
megadása következik. Ezért hibához vezet, ha a forma
első eleme maga a LAMBDA szimbólum, nem pedig a
lambdakifejezés. Használata: ((LAMBDA l f1 f2 ... fm) p1
p2 ... pn)
 Példa: ((lambda (n) (+ n 1)) 5)
 Rekurzivitás lambdakifejezésekben: címkézéssel
((LABEL név (LAMBDA l f1 f2 ... fm)) p1 p2 ... pn)

63
Példa a LAMBDA alkalmazására

(DEFUN UJ-SUBST (UJ REGI LISTA)

;bármely szinten helyettesít
(COND ((EQUAL LISTA REGI) UJ)
((ATOM LISTA) LISTA)
(T (MAPCAR
(FUNCTION (LAMBDA (ELEM)
(UJ-SUBST UJ REGI ELEM))) LISTA))))

64
Példa a LAMBDA alkalmazására

; MAA = minden atomra alkalmazd

(DEFUN MAA (L FGV)

(COND ((NULL L) NIL)
((NOT (LISTP L)) (APPLY FGV (LIST L)))
(T (MAPCAR (FUNCTION (LAMBDA (ELEM)
(MAA ELEM FGV))) L))))

;pl. '(1 (2 3 (4 5)) (6 7)) '1+

65
Példa a LABEL alkalmazására
;f(0)=f(1)=1, f(n)=f(n-1)+f(n-2), ha n>1

DEFUN FIBONACCI (N)

((LABEL FIB-GYŰJTŐ
(LAMBDA (I FI FI1)
(COND (EQUAL I N) FI1) ;megállási feltétel
(T (FIB-GYŰJTŐ (+1 I) ;következő
FI1 ;f(i)
(+ FI FI1)))))) ;f(i+1)
1 1 1)) ;i=1, fi=1, fi1=1

66
Laborfeladatok
 Számokat tartalmazó lista legnagyobb elemének kiválasztása
(LEGNAGYOBB l)
 Számokat tartalmazó lista legkisebb elemének kiválasztása
(LEGKISEBB l)
 Számokat tartalmazó lista átlagának visszatérítése (ÁTLAG l)
 Lista adott elemének törlése felső szinten (TÖRÖL e l)
 Lista adott elemének törlése minden szinten (MINDTÖRÖL e l)
 Azonos elemeket is tartalmazó lista ,,halmazosítása’’ gyűjtőváltozó
módszerével (HALMAZOSÍT l)
 segédfüggvény: (HALM-SEGÉD l1 l2)
 l1: az eddig talált atomok listája
 l2 az l be nem járt része
 Megállási feltétel: mikor az l2 üres lista lesz (nincs mit bejárni)
 Ha l1-ben már megvan az éppen vizsgálandó elem, akkor változatlan
marad, különben az elem bekerül l1-be
 Fakultatív: Matematikai kifejezés prefixes formára alakítása
(alapműveletek: összeadás, kivonás, szorzás, osztás, hatványozás)

67
Lispbox (Lisp in box)

 EMACS – szövegszerkesztő (Editor

MACroS)
 SLIME=Superior Lisp Interaction
Mode for Emacs – környezet , mely
megengedi, hogy kapcsolatban legyél
a REPL és a forrásállomány között
 REPL – Read Eval Print Loop
 SLDB – Common Lisp Debugger –
nyomonkövető program
68
Emacs parancsok
 Ctrl-x Ctrl-f: állomány megkeresése vagy
létrehozása;
 Ctrl-x Ctrl-f: állomány mentése
 Ctrl-x Ctrl-w: elmenti az aktuális tartalmat
az alsó sorban megadható filenév alá
 Ctrl-x Ctrl-b: pufferek (átmeneti tárak)
listázása
 Ctrl-x 1: egyetlen ablak
 Ctrl-x 2: két ablak használata
 Ctrl-x u: visszalépés
 Ctrl-x Ctrl-c: kilépés a szövegszerkesztőből
69
 Emacs parancsok
 Ctrl-c Ctrl-q: zárójelek bezárása a definíció
végén
 Ctrl-c Ctrl-c: a DEFUN kompilálása
 Ctrl-c Ctrl-z: áttérés a REPL-hez (vagy Ctrl-x b)
 Ctrl-c Ctrl-s: mentés (puffer mentése)
 Ctrl-g: megszakít egy parancsot
 Ctrl-h f: függvény leírása
 Ctrl-h a: Command apropos – a megadott
kulcsszót tartalmazó összes utasítást kilistázza
 Ctrl-h k: az utána nyomott
bilentyűkombinációról írja le, hogy mit csinál
70
Egyéb parancsok a Lispbox használatakor

 Kilépés a LISP-ből: a REPL ablakocskába

vesszőt (,) gépelünk, majd az Emacs ablak
alján beírjuk a quit parancsot, utána pedig
Enterrel zárjuk.
 SLIME újraindítása: Alt-x, majd begépeljük
az Emacs-be a SLIME parancsot.
 Kilépés a debuggerből: q
 Ctrl-h ?: súgó a HELP-ről.

71
Hivatkozások

 http://people.inf.elte.hu/istenes/lisp/
 http://apsymac33.uni-trier.de:8080/Lisp-
Course
 http://www.cs.cmu.edu/~dst/LispBook/boo
k.pdf
 http://www.cliki.net/Online%20Tutorial
 http://www.cs.sfu.ca/CC/310/pwfong/Lisp/
 http://www.nicklevine.org/declarative/lectu
res/index.html#additionals

72