LISP programozási nyelv

Az előadások a következő témára: "LISP programozási nyelv"— Előadás másolata:

1 LISP programozási nyelv
Készült a Programozási nyelvek és paradigmák összehasonlítása gyakorlatra Írta: Kolonitsné Dávid Diána

2 Tartalom: Bevezetés Szintaxis A nyelv elemei Utasítások és vezérlési szerkezetek Objektumorientáltság Párhuzamosság Kivételkezelés Fájl kezelés Makró

3 Bevezetés 1958: John McCarthy alkotta meg.
mesterséges intelligencia területén gyorsan elterjedt. a Lisp a második legöregebb magas szintű programozási nyelv (a FORTRAN után). számos nyelvjárása létezik: Mindegyikben közös az S-kifejezések szerepe és szerkezete. a legtöbb nyelvjárásnak több megvalósítása is készült Az egyes nyelvjárások között komoly eltérések lehetnek.

4 Az atomok és listák összefoglaló neve.
S-kifejezéseknek Az atomok és listák összefoglaló neve. S-kifejezések formálisan: Minden atom S-kifejezés. Ha X és Y S-kifejezés, akkor (X . Y) is S-kifejezés, amit párnak nevezzük Ha S1,S2,...Sk S-kifejezések, akkor (S1 S2 ... Sk) is S-kifejezés, amit listának nevezünk. Minden olyan objektumot, ami az 1, 2, 3 szabály alkalmazásával áll elő S-kifejezésnek nevezünk. A LISP nyelvben mind a programok, mind pedig az adatok, amelyeken a programok dolgoznak, S-kifejezésekből állnak. Egy LISP program S-kifejezések egymásutánja

5 Szintaxis kifejezés orientált nyelv: a kódot adatként kezeli
nincs különbség „kifejezések” és „parancsok” között, minden adatot és utasítást kifejezések formájában írunk le. a kódot adatként kezeli Az értékek típusa implicite adott Lista: (1 2 "abc") üres lista () vagy nil

6 list: visszaadja az argumentumaiból alkotott listát
A kifejezéseket lista alakban írjuk, mégpedig prefix jelölést használva. Ahol a lista legelső eleme egy művelet. Pl.: list: visszaadja az argumentumaiból alkotott listát (list 1 2 (list 3 4)) - > (1 2 (3 4)) számtani műveletek hasonlóan: ( ) -> 10 Szintaxis 2

7 Fontosabb lista műveletek:
(cons elem lista): Elem befűzése a lista elejére. Itt az elem lehet atom és lista típusú is. (append args): Listák építésére. Ez a megadott argumentumokból listát épít. Fontos, hogy az argumentumok csak listák lehetnek.  (first, second ...): Listák egyes elemeire hivatkozhatunk. A kulcsszavak száma fordító függő. A Common Lispben jelenleg 10-ig engedélyezett.  (first lista) eredménye a lista első eleme.  (nth n lista): A lista n-edik elemét érhetjük el.  (nthcdr n lista): A lista n-edik elemétől a visszamaradó részt érhetjük el.  Szintaxis 3

8 (setq a (list 1 2 3)) (setq b (cons 0 (cdr a)))
Megosztott struktúra A Lisp listák, lévén hogy egyszerű láncolt listák, tartalmazhatnak közös, megosztott szakaszokat. Nevezetesen, két (vagy több) listának lehet ugyanaz a farka. Például: (setq a (list 1 2 3)) (setq b (cons 0 (cdr a))) az a és b változók rendre az (1 2 3) és a (0 2 3) értéket veszik fel. A (2 3) szakasz közös ha ez valamilyen módon megváltoztatnánk, mindkét lista értéke megváltozna. Szintaxis 4

9 Önazonos kifejezések és az idézés
A Lisp-ben lehetőségünk van arra is, hogy egy értéket megvédjünk a kiértékeléstől. Erre szolgál az idézés, amelyet röviden egy felülvesszővel ( ’ ) is jelezhetünk. (setq kif ’kif) Ezután akármilyen mélységben értékeljük ki a kif kifejezést, mindig önmagát fogjuk kapni. Szintaxis 5

10 Kiértékelés és a OKK (REPL)-ciklus
a Lisp parancssori végrehajtást gyakran "olvasás-kiértékelés-kiírás" vagyis OKK-ciklusnak hívjuk. A ciklus három ütemének egy-egy alapvető Lisp függvényt lehet megfeleltetni: Read: beolvassa egy S-kifejezés írott reprezentációját, eredményként annak belső ábrázolását adja. Eval: kiértékeli az argumentumaként kapott listaszerkezetet, egy újabb struktúrát adva eredményül. Az eredményként kapott érték a teljes kiértékelés végeredménye is egyben. Print: feladata az argumentuma megjelenítése a felhasználónak. Egyszerű értékek esetén ez a feladat triviális, bonyolultabb struktúrák, listák esetében azonban a teljes struktúra bejárását igényli. Szintaxis 6

11 A nyelv elemei Szám: Lisp csak egész típusú számokat enged
Karakter: #\ a jele Konstansok: NIL vagy (): Mind a kettő konstans az üres listát jelöli. T: az igaz értéket jelölő atom. Komment: ;-tel. Hatásuk a sor végéig tart. Többsoros komment írására nincs lehetőség.

12 Tömbök Létrehozás (make-array ‘(2 3)) -> ((NIL NIL NIL) (NIL NIL NIL)) setq: a szimbólumnak értékül adja a tömböt. (setq a (make-array 3)) -> #(NIL NIL NIL) aref: tömb i. indexű elemét adja vissza (aref a 1) -> NIL setf : a tömbelemet lecseréli: (setf (aref a 1) 3) -> #(NIL 3 NIL) ; Mindig nullától indexelün push: az a tömb megadott elemének értéke megváltozik (push 5 (aref a 0)) pop: kiveszi a megadott tömbelemet (pop (aref a 0)) incf: kiolvassa az értéket, eggyel növeli, és visszaírja (incf (aref a 0)) Nyelvi elemek 2

13 Vektorok: Lisp-ben egy vektort egy, 1 egydimenziós tömböt, amelynek elemei tetszőleges típusú objektumok lehetnek, az elemeik felsorolása jelez a #( és ) szimbólumok között. #(a b c) Bit Tömbök: Ezek olyan tömbök melynek elemei csak 0 vagy 1 lehet. Ezek létrehozása a make-array függvénnyel vagy a #*karakterrel lehetséges. (make-array 10 :element-type 'bit) #*100000 String Nyelvi elemek 3

14 Utasítások és vezérlési szerkezetek
Függvények kezelése SETQ: függvény, amely egy szimbólumhoz hozzárendelnek egy értéket. Lsd.: vektor. (SETQ szimb.atom kifejezés) QUOTE: megtiltja az argumentumának kiértékelését mit a már korábban említett ‘. (SETQ A (QUOTE SZIA)) -> SZIA DEFUN: Saját függvényt definiálhatunk. (DEFUN fvnév (paramlista) (törzs))

15 Szekvencia Ez sorra kiértékeli a listákat, majd az utolsó kiértékelés eredményével tér vissza. (LET ((változó1 initkif1) (változó2 initkif2) ...) kif1 kif2 ...) (LET* ((változó1 initkif1) (változó2 initkif2) ...) kif1 kif2 ...) LET esetén az inicializáció párhuzamosan történik abban az értelemben, hogy az inicializációs kifejezések még nem látják az újonnan kötött változókat. LET* esetén az inicializáció szekvenciálisan történik. A következő példa segít ennek megértésében: Ennek az értéke 11 (LET ((x 10)) (LET ((x 20) (y x)) (+ y 1))) Ezé viszont 21 (LET ((x 10) (LET* ((x 20) (y x)) (+ y 1))) Utasítások és vezérlési szerkezetek 2

16 (OTHERWISE utasítás))
Elágazás (IF (feltétel) (igaz ág utasítása) (hamis ág utasítása)) Van CASE is: (CASE (kif) (atom1 utasítás1) (atom2 utasítás2) ... (OTHERWISE utasítás)) Az összehasonlítás EQ szerint történik. Ha egyik atommal sem egyezik meg a kifejezés értéke, és nincs OTHERWISE ág, akkor nil értéket kapunk. A CASE makró egy másik változata az ECASE, amelyben nem adhatunk meg OTHERWISE ágat, és ha nincs illeszkedő ág, akkor TYPE-ERROR szignált kapunk. Utasítások és vezérlési szerkezetek 3

17 (COND (feltétel1 tevékenység1) (feltétel2 tevékenység2) ...
Feltételes kifejezés 1. Egy feltételes kifejezést a COND függvény segítségével írhatunk le. A függvény általános alakja: (COND (feltétel1 tevékenység1) (feltétel2 tevékenység2) ... (feltételN tevékenységN)) A feltételes kifejezés kiértékelése: Először az első argumentum első eleme, azaz feltétel1 értékelődik ki. Ha a feltétel1 S-kifejezés értéke igaz, akkor kiértékelődik az argumentum második eleme, a tevékenység1 kifejezés, és ez lesz az egész feltételes kifejezés értéke. Ilyenkor a feltételes kifejezés további argumentumai nem értékelődnek ki. Ha azonban a feltétel nem teljesül, azaz feltétel1 értéke NIL, akkor tevékenység1 kifejezés nem értékelődik ki, és a kiértékelés a második argumentummal, ill. a további argumentumokkal ugyanígy folytatódik mindaddig, amíg valamelyik feltételnek az értéke igaz nem lesz. Ekkor az ehhez a feltételhez tartozó tevékenység értéke lesz a kifejezés értéke. Ha egyik feltétel sem teljesül, a kifejezés értéke NIL lesz. Utasítások és vezérlési szerkezetek 4

18 (when (feltétel utasítás1 utasítás2 ... utasításn)
Feltételes kifejezés 2 A feltételes kifejezéseknél használhatjuk a when és unless függvényeket is.  A when szintaxisa: (when (feltétel utasítás1 utasítás2 ... utasításn) When esetén ha a feltétel igaz volt akkor a when után szereplő összes utasítás végrehajtódik.  Az unless szintaxisa.  (unless (feltétel utasítás1 utasítás2 ... utasításn) unless esetén ha a feltétel hamis volt akkor az unless után szereplő összes utasítás végrehajtódik. Utasítások és vezérlési szerkezetek 5

19 Ciklus Az iteráció a nemfunkcionális programozási nyelvek egyik legjellemzőbb programozási eszköze. Segítségével a program egy részét többször is végre lehet hajtani. A LISP-ben azt nevezzük iterációnak, ha egy formát egymás után többször kiértékelünk, és egy meghatározott feltétel teljesülésétől függ, hogy meddig kell a kiértékelést ismételnünk. A funkcionális nyelvek alapvetően a rekurzív függvényeket szeretik, de hatékonysági okokból (tár és idő) az imperatív nyelvekre jellemző iterációs "utasítások" is bekerültek. Utasítások és vezérlési szerkezetek 6

20 Számlálásos ciklus: az RPT makró
Ennek segítségével azt írhatjuk elő, hogy egy S-kifejezés hányszor értékelődjön ki. A makró alkalmazásakor a második argumentum értéke annyiszor ismétlődik meg, amennyi az első argumentum értéke. A kifejezés értéke a második argumentum utoljára kapott értéke lesz. Utasítások és vezérlési szerkezetek 7

21 Elöltesztelő ciklus: a WHILE makró
A WHILE makró segítségével olyan ciklusokat szervezhetünk, amelyekben a kifejezés mindaddig kiértékelődik, amíg egy feltétel teljesül. A WHILE akárhány argumentumú, de legalább két argumentumot meg kell adni. Az első argumentum tetszőleges S-kifejezés (megállási feltétele ), amely mindig kiértékelődik. Ha értéke nem NIL, kiértékelődnek a további argumentumok is, majd ismét az első argumentum értékelődik ki és így tovább. A WHILE függvény értéke mindig NIL. Utasítások és vezérlési szerkezetek 7

22 Az UNTIL makró éppen a WHILE fordítottja.
Argumentumait ugyanúgy kell megadnunk, mint a WHILE esetében, de a második és a további argumentumok csak akkor értékelődnek ki, ha az első argumentum (a megállási feltétel) értéke NIL. Ez ismétlődik mindaddig, ameddig az első argumentum értéke először bizonyul igaznak. Az UNTIL értéke ez az érték lesz. Utasítások és vezérlési szerkezetek 8

23 A DO általános alakja: A DO makró
(DO ((változó_1 érték_1) (változó_2 érték_2) ... (változó_m érték_m)) (feltétel tevékenység) S-kifejezés_1 S-kifejezés_2 S-kifejezés_n) A DO makró Az első argumentum a változólista, amely kételemű allistákból áll. Az allisták első eleme tetszőleges szimbólum lehet, ezeket DO-változóknak nevezzük, a második elem pedig tetszőleges S-kifejezés lehet. A DO kiértékelésének kezdetekor minden változónak az értéke a hozzá tartozó S-kifejezés értéke lesz. A DO kiértékelése után a DO-változók elveszítik lokális értéküket, és ha volt előzőleg értékük, azt visszakapják. A DO második argumentuma egy kételemű lista, amelynek elemei tetszőleges S-kifejezések lehetnek. A DO harmadik és esetleges további argumentumai tetszőleges S-kifejezések lehetnek, ezek alkotják a DO törzsét. Ha a megállási feltétel értéke NIL, akkor a törzset alkotó S-kifejezések egymás után kiértékelődnek. Az utolsó S-kifejezés után újra kiértékelődik a feltétel - és azt követően minden S-kifejezés - egészen addig, amíg a feltétel értéke igaz érték nem lesz. Ekkor értékelődik ki a megállási feltétel után álló tevékenység, és ennek értéke lesz a DO kifejezés értéke. Utasítások és vezérlési szerkezetek 9

24 A PROG speciális forma lehetővé teszi, hogy a kifejezéseket
A PROG-kifejezések alakja: (PROG (változó_1 változó_2 ... változó_m) S-kifejezés_1 S-kifejezés_2 ... S-kifejezés_n) A PROG speciális forma Speciális DO makró A PROG speciális forma lehetővé teszi, hogy a kifejezéseket tetszőleges sorrendben értékeljük ki. A kifejezés első eleme a PROG szimbólum, ezután következik a PROG változóinak listája. A PROG-változóknak kezdetben NIL az értéke. A változólista után tetszőleges S-kifejezés következik (címke, GO álfüggvény, RETURN álfüggvény). Ha a PROG törzsének utolsó S-kifejezése is kiértékelődött, és ez nem tartalmazott olyan GO-kifejezést. melynek hatására a kiértékelés a törzs valamely más helyén folytatódik, akkor a PROG kiértékelése befejeződik. A PROG kiértékelése akkor is befejeződik, ha a törzsben egy RETURN kifejezés kiértékelődik. Ennek alakja: (RETURN S-kifejezés) Utasítások és vezérlési szerkezetek 10

25 Végtelen ciklus esetén nem adunk meg kilépési feltételt.
A LOOP makró Az újabb lisp verziókban megtalálható a loop makró is. Ezzel széles lehetőségünk nyílik a különböző formátumú ciklusok használtára.  Végtelen ciklus esetén nem adunk meg kilépési feltételt. Például: (loop (print 'ciklus))  Lehetőségünk van egy loop ciklust egy tartományom belül is lefuttatni. (loop for x from 1 to 3 do (print x)) to helyett downto-val csökkent Ezen felül gyűjteményeket is bejárhatunk a loop makró segítségével. (loop for (item) on '(1 2 3) do (print item))  Utasítások és vezérlési szerkezetek 11

26 Objektumorientált programozás
A DEFSTRUCT automatikusan definiál slotokat : PERSON-NAME jellegűeket a slot-értékek beállításához és kiolvasásához, és egy MAKE-PERSON nevűt, mely az inicializálst végzi a megadott argumentumokkal. (make-person :name 'george :age 12) A slot az attribútumok és metódusok összefoglaló neve. DEFSTRUCT (DEFSTRUCT person (name 'bill) (age 10))

27 Osztályokat a DEFCLASS függvénnyel lehet definiálni:
(DEFCLASS osztály-név (szülő-osztály-neve*) (slot-leírás*) osztály-opció*) ; * Elhagyható Többszörös öröklődés engedélyezett. Objektumorientált programozás 2

28 A DEFSTRUCT-hoz hasonló működés létrehozásaához a következő kód kell:
(defclass person () ((name :accessor person-name :initform 'bill :initarg :name) ((age :accessor person-age :initform 10 :initarg :age))) A DEFSTRUCT-hoz hasonló működés létrehozásaához a következő kód kell: A DEFCLASS alkalmazásával a programozó határozhatja meg, mit hogy hívjanak. A DESCRIBE OSZTÁLY függvény alkalmazásával információhoz juthatunk az osztály felépítéséről és további paramétereiről. Nem kötelező az összes opció beállítása minden slot számára. Ha egy struktúrát definiálunk a Lisp-ben, ahhoz több funkció automatikusan generálódik (pl. példánylétrehozó, típuslekérdező függvény stb.), osztályt alkalmazva azonban több dolgot kell a programozónak magának megadnia. Objektumorientált programozás 3

29 Osztályok metódusai vagy metódusok osztályai
A LISP funkcionális nyelv, tehát a matematikai függvényfogalomra épít. Ez nyomot hagy az objektumelvű részeken is. Az objektumelvű imperatív nyelvekkel szemben, a metódusok nem egy konkrét osztályhoz tartoznak, hanem azokhoz, melyek hívását metódus argumentumai lehetővé teszik. Melyik hajtódik végre az azonos metódusok közül? Az, melynek argumentumai illeszthetők az "aktuális paraméterekre", és az illeszthetők közül a legspecifikusabb argumentumlistával rendelkezik. Objektumorientált programozás 4

30 Osztály példánya a MAKE-INSTANCE kulcsszóval hozható létre.
Osztályok példányai Osztály példánya a MAKE-INSTANCE kulcsszóval hozható létre. (MAKE-INSTANCE class {initarg value}*) konstruktort létrehozása: (defun make-person (name age) (make-instance 'person :name name :age age)) Objektumorientált programozás 5

31 Párhuzamosság A Lisp maga nem támogatja, ennek használatához Symmetric Lisp szükséges, amely a Lispben megszokott függvényeket támogatja. Lehetővé teszi környezetek írását, amelyek a nyelv objektumai. A környezet olyan szerkezet, ami szimbólumokat kapcsol össze jelentésükkel vagy értékükkel. Mivel a környezet elemeinek kiértékelése párhuzamosan történik, a Symmetric Lisp párhuzamos programozási nyelv.

32 Kivételkezelés Lisp-ben három szereplős a kivételkezelés:
A kiváltó kód szerepe analóg a hagyományos dobóéval. A kezelő kód, ő aki a kivétel létrejötte esetén meg tudja menteni a helyzetet. Esetleg többféleképpen is meg tudja oldani, viszont a megoldáshoz szüksége lehet olyan információkra is, amiket eddig nem ismerhetett. Összeállít egy listát a lehetséges megoldásokról (ezek az úgynevezett újrakezdések, és az ezekhez szükséges adatokról, és továbbküldi azokat. A harmadik szereplő a döntéshozó, az a kód, amely a kezelő által adott lehetőségek közül választ, és biztosítja az általa választott megoldáshoz szükséges kiegészítő információkat. Nem kötelező ez a forma, a hagyományos megvalósítás is lehetséges.

33 Kivételek: Kivételkezelők Döntéshozók
(DEFINE-CONDITION név (ősosztály*) (slot-leírás*) osztály-opciók) Kivételek: Kivételeket a DEFINE-CONDITION makróval definiálhatunk. Egy kivétel valójában egy speciális osztály. Kivételkezelők A kivételkezelők a program egy részét úgy hajtják végre, hogy ha azokban meghatározott típusú kivételek lépnek fel, akkor a helyzetet különböző újrakezdésekkel tudják kezelni. Ehhez a RESTART-CASE makrót használjuk: Döntéshozók A felkínált újrakezdéseket a  INVOKE-RESTART függvénnyel hívhatjuk meg. Az egyes kivétel-típusokhoz pedig a HANDLER-BIND  makróval rendelhetünk kezelő-függvényeket. (RESTART-CASE kifejezés (megoldás-1 (paraméterek-1) kifejezés-1) (megoldás-2 (paraméterek-2) kifejezés-2) ...) HANDLER-BIND ((kivétel-1 kezelő-1) (kivétel-2 kezelő-2) ...) kifejezés) (INVOKE-RESTART újrakezdés paraméterek) Kivétel kezelés 2

34 Fájlkezelés A Common Lisp gazdagon el van látva a fájlkezeléshez szükséges könyvtárakkal, függvényekkel. A nyelv alapvető fájl I/O eszközei hasonlóan működnek más nyelvekéhez. írásés olvasás, fájlnevek manipulálása, Továbbá, a Common Lisp egyedi funkcionalitásokat biztosít az S-kifejezések írására és olvasására.

35 Makrók Egy makró egy speciális függvény, amelynek a bemenete és a kimenete programkód-fa. Makrókat ennek megfelelően a függvényekhez hasonlóan definiálhatunk. Ahogy a függvényeknek formális paraméterei vannak, úgy a makróknak paraméter helyett szintaxisuk van, vagyis a programfának egy alakja, amiben az egyes részfák a makróalkalmazás helyének megfelelő értéket vesznek fel. Ezt a programfa-alakot a függvények formális paramétereihez hasonlóan specifikáljuk: (DEFMACRO makrónév (szintaxis) kifejezés)

36 Az alábbi példa szekvenciává lapítva valósítja meg a fordítási időben ismert iterációt tartalmazó ciklust: (DEFUN sokszoroz (n kifejezes) (LOOP FOR i FROM 1 TO n COLLECT kifejezes)) (DEFMACRO lapitott-ciklus (n &body body) (CONS 'PROGN (sokszoroz n (CONS 'PROGN body)))) Ahol: A &body kulcsszó azt jelenti, hogy a második paramétertől kezdve tetszőleges számú paraméter megengedett, és ezek összessége lesz, mint lista, a body formális paraméter aktuális értéke.

37 Köszönöm a figyelmet!

38 Kérdések: Hogyan írjuk az 4+32+12 kifejezést Lisp-ben?
Milyen módszereket ismersz arra, hogy a Lisp ne értékeljen ki egy kifejezést? Lisp-ben WHILE makró esetén mi lesz a függvény értéke?