Doktori értekezés. Diviánszky Péter 2012.
|
|
- Dezső Kocsis
- 5 évvel ezelőtt
- Látták:
Átírás
1 Doktori értekezés Diviánszky Péter 2012.
2
3 Referenciák tisztán funkcionális nyelvekben Diviánszky Péter ELTE IK Informatika Doktori Iskola Az informatika alapjai és módszertana oktatási program vezető: Dr. Benczúr András, egyetemi tanár, mat. tud. doktora Programozási Nyelvek és Fordítóprogramok Tanszék témavezető: Dr. Horváth Zoltán tanszékvezető egyetemi tanár The research was supported by the Hungarian National Science Research Grant (OTKA), Grant Nr. T037742, by GVOP /3.0 ELTE IKKK and OMAA-ÖAU 66öu2, by the European Union and co-financed by the European Social Fund (grant agreement no. TAMOP /B-09/1/KMR )
4 Papp Zoltán tanár úr és a bátyám révén kerültem kapcsolatba a tisztán funkcionális programozással, ami rögtön megragadott a matematikával való szoros kapcsolata miatt. Ezután Nijmegenben az Ivicsics Mátyással, Várnagy Zoltánnal és Rinus Plasmeijerrel való találkozás meghatározó volt abban, hogy később elkezdjem a doktori programot. Budapesten a tanszéki értekezleteken többek között Kozsik Tamás, Csörnyei Zoltán, Horváth Zoltán, Porkoláb Zoltán, Zsók Viktória, Lövei László és Tejfel Máté tudományos vitáit élvezhettem, majd Hegedűs Hajnalkával dolgozhattam együtt a Clean és Haskell fordítók közti kapcsolat megteremtésén. Csörnyei Zoltán a TDK témavezetésével is hozzásegített a doktori iskolában való részvételhez. A doktori program elkezdése után Szabóné Nacsa Rozáliával és Horváth Zoltánnal dolgozhattam együtt a funkcionális programok átfogalmazásán és több tudományos konferencián is részt vehettem velük. Eközben Erdélyi Gáspárral lelkesen kezdtük kutatni a referenciák szerinti egyenlőségvizsgálatot és a gráfok destruktív módosítását. Nijmegenben újra Rinus Plasmeijer segített a témavezetésével, John van Groningen pedig ABC kódot magyarázott. A bemutatott doktori értekezés témája innen ered. A munkámban közös beszélgetésekkel is segítettek többek között munkatársaim, Mészáros Mónika, László Ildikó, Kitlei Róbert, Dévai Gergely, Góbi Attila, és barátaim, Barczy Mátyás, Vértesi Tamás és Páli Gábor. A diákjaim és az F#, majd az MCore projekt tagjai gondoskodtak arról, hogy eközben véletlenül se unatkozzak. A munkámban többek között a tanszéki adminisztrátorok, a testvéreim, a szüleim, a rokonaim és édesanyám osztálytársai is támogattak, a témavezetőm hatékonyan rávett az egyes cikkek megírására, a nagymamám pedig rávett a doktori értekezés befejezésére. Mindezeket nagyon köszönöm!
5 Tartalomjegyzék 1. Tézisek Kapcsolódó publikációk Bevezetés Hivatkozások behelyettesíthetősége Kapcsolódó fogalmak Kihívások a hivatkozások behelyettesíthetősége esetén Referenciák megvalósítása Megoldások összefoglalása Bevezetés a tisztán funkcionális programozásba A Haskell modulrendszere Lexikális elemek Kifejezések Függvényalkalmazás Operátorok alkalmazása N-esek Listák Függvénydefiníciók Egyszerű függvény- és konstansdefiníciók Mintaillesztés Esetszétválasztás Lokális definíciók Magasabbrendű függvények Szigorú statikus típusozás Típusdefiníciók Típus szinonima definíciók
6 Algebrai adattípusok Absztrakt típusok Típusosztályok Típusosztályok definiálása Dinamikus típusozás Akciók Az akciók típusa Elemi akciók, akciók összekötése A do kifejezés Monádok Példa monádokra Funktorok Kiértékelési stratégiák A kiértékelési sorrend módosítása A érték Haskell nyelvi kiterjesztések Felhasznált módszerek Veszélyes függvények Magasabb rangú típusok Egzisztenciális típusozás Fantom típusváltozók Számítások típusokon Adatok típusokkal való reprezentálása Típusfüggvények Egyediségi típusozás Bevezetés az egyediségi típusozásba Egyediség ellenőrzés futási időben
7 5. Kapcsolódó munkák Véges leképezések A véges leképezés műveleteinek erőforrásigénye Monadikus referenciák IO-referenciák ST-referenciák Monád-független interfészek Heapek Cleanben Referencia egyszerűsített olvasása Problémák Mellékhatás-típusozás Referenciák kiváltása véges leképezésekkel Példa a véges leképezések használatára Módosított véges leképezések Típusváltozóval címkézett azonosítók Példák a használatra Véges halmazok Erősen összefüggő gráfkomponensek kiszámolása Reláció inverzének kiszámolása Erősen összefüggő gráfkomponensek kiszámolása A sorozat adatszerkezet A módosított véges leképezések implementálása A foltozási technika alapjai A végleges adatszerkezetek Az azonosítók műveletei Kiegészítések az implementációhoz Összefoglalás
8 7. Referenciák kiváltása heapekkel Bevezetés Általános interfész Referencia olvasás és írás Új referencia készítése Egyedi állapot megkettőzése Mag létrehozása Heap magok Hatékony implementáció Példa (első változat) Referencia implementáció A hatékony és a referencia implementáció kapcsolata Homogén heapek Referencia implementáció Különálló magok Hatékony implementáció Referencia implementáció Törölhető referenciák Referencia implementáció Általános függvények Osztott referenciák Hatékony implementáció Referencia implementáció Példa (második változat) Heapek uniója Címke altípusozás Az unió típusosztály Példa (harmadik változat)
9 7.10. Referenciák egyenlőségvizsgálata A modellek összehasonlítása Alkalmazások Konstans memóriát használó szemétgyűjtés Erősen összefüggő gráfkomponensek kiszámolása Diszjunkt halmazok Típusegyenlet-rendszer megoldása Összefoglalás Algebrai adatban szereplő referenciák azonosságvizsgálata Bevezetés Az alapötlet Áttekintés Az alapnyelv Az új nyelvi elemek definíciója Szintaxis Szemantika és típusozás A kibővített nyelv bővítése újabb nyelvi elemekkel Egy teljes példa Fordítás gráfátíró rendszerekkel Gráfátíró rendszerek A gráfátíró rendszer kibővítése A kibővített nyelv tulajdonságai A new terjedési szabály enyhítése Prototípus implementáció Cleanben Az ABC nyelv Kapcsolódó munkák A ν-kalkulus Összefoglalás
10 9. Összegzés Summary Függelék: Gráfátíró rendszerek 149 8
11 1. Tézisek A doktori értekezésemben megmutatom, hogy a referenciák a monadikus modell mellett milyen más konstrukciókkal válthatók ki tisztán funkcionális nyelvekben. Első tézis Referenciák hatékonyan kiválthatók véges leképezésekkel Definiáltam egy módosított véges leképezés adatszerkezetet, amely hatékonysága miatt alkalmas referenciák kiváltására. 6. fejezet, [8], [9] cikkek, [10] kapcsolódó cikk. A véges leképezés adatszerkezet egy olyan asszociációs listának felel meg, amelyben a kulcs érték párok sorrendje nem definiált. A referenciák kiválthatók véges leképezésekkel úgy, hogy a referenciák helyett kulcsokat használunk és a referenciák által hivatkozott értékeket egy, a kulcsokat tartalmazó véges leképezésben tartjuk. Amennyiben referenciák kiváltására használjuk a véges leképezéseket, a következő feltételek általában teljesíthetőek: Bármely kulcs értékének írása után a kulcshoz tartozó korábbi értéket nem írjuk vagy olvassuk. Ez a feltétel teljesül referenciák esetén mivel ott nincs lehetőség a referencia írása előtti környezetre hivatkozni. A program futása során használt véges leképezések számára előre rögzített felső korlát van. Referenciák esetén ahol csak egyetlen, globális környezet áll rendelkezésre, aminek a feldarabolásával kapjuk a véges leképezéseket, amiknek a száma többnyire fordítási időben rögzített. A módosított véges leképezések elemi műveletei, úgymint az írás, az olvasás, a kulcsok készítése és összehasonlítása konstans erőforrás igényűek, ha a fenti két természetes feltétel teljesül. Ez a tény alátámasztja hogy a módosított véges leképezések alkalmasak referenciák kiváltására. Az elemi műveletek konstans erőforrásigényéből következik, hogy a program futása során használt kulcsok száma nem befolyásolja a műveletek 9
12 erőforrás igényét. Ez a tulajdonság eltér a szakirodalomban ismert véges leképezés adatszerkezetekétől, amikben az elemi műveletek hatékonysága egyenesen arányos a kulcsok számának a logaritmusával. Második tézis Általános interfész adható heapeknek Definiáltam egy általános heap interfészt mellyel lehetséges referenciák távoli létrehozása, heterogén és homogén heapek használata, osztott referenciák használata és a heap unió művelete, és ezen interfész hat különböző lehetséges implementációjának szemantikai vizsgálatát is elvégeztem. 7. fejezet, [12] cikk. Heapnek nevezzük a memória absztrakt leírásában azt a részt, amely memóriahely érték párok halmazaként képzelhető el. A heap tekinthető egy nem perzisztens véges leképezésnek is. Heapekkel kiváltható a referenciák használata tisztán funkcionális nyelvekben, ha a nyelv támogatja az egyediségi típusozást. Definiáltam egy általános heap interfészt. Az interfészben lehetővé tettem referenciák távoli létrehozását, heterogén és homogén heapek használatát, és referenciák megosztott használatát. Definiáltam a heap unió műveletet is. Megadtam 6 lehetséges heap modellt az általam definiált heap interfészhez, és ezeket össze is hasonlítottam. Megmutattam, hogy a Clean nyelvben használt heapek elláthatók az általam definiált interfésszel, és ezzel javítható a korábbi Clean heap interfésznek egy jelentős hibája. Harmadik tézis Biztonságossá tehető a referencia szerinti azonosságvizsgálat Kidolgoztam az algebrai adattípusok referencia szerinti azonosságvizsgálatát. 8. fejezet, [7] cikk, [5], [6] kapcsolódó cikkek. 10
13 Funkcionális nyelvekben az algebrai adattípusok implementációja többnyire referenciákkal történik: minden konstruktorból referenciák mutatnak a konstruktor paramétereihez. Ezek a referenciák mintaillesztéssel olvashatók, a referenciák írása és azonosságvizsgálata viszont nem megengedett, mivel elrontaná a hivatkozások behelyettesíthetőségét. Kibővítettem egy tisztán funkcionális nyelvet referencia szerinti egyenlőségvizsgálattal úgy, hogy egyszerű feltétel adható a hivatkozások behelyettesíthetőségére és teljesül a függvénydefiníciók behelyettesíthetősége, szemben a ν-kalkulus[29] megoldásával. Ezeket az állításokat bizonyítottam is Kapcsolódó publikációk Folyóirat cikkek [11], [12]. Referált cikkek [7], [8]. Absztraktok [5], [6], [9], [10]. 11
14 12
15 2. Bevezetés 2.1. Hivatkozások behelyettesíthetősége A funkcionális nyelvek sikerében jelentős szerepet játszik a hivatkozások behelyettesíthetősége. A hivatkozások behelyettesíthetőségének definiálásához először egy-egy példával megnézzük a változó helyettesítés és a környezet fogalmát. Példa változó helyettesítésre: (1 / x + 3 x)[x := 6 + 5] = 1 / (6 + 5) + 3 (6 + 5). A környezet nem más mint definíciók halmaza, például {x = 4 5; y = 3 + x}. A hivatkozások behelyettesíthetősége (angolul referential transparency) egy adott környezet, egy kifejezés és egy változó esetén azt jelenti, hogy a kifejezésben a változó kicserélhető a definíciójára anélkül, hogy a kifejezés jelentése megváltozna: e e[v := a] ha {... ; v = a;... } Példa: Legyen a környezet {x = 1 + 1}, legyen a kifejezés x + x és legyen a változó x. Az adott környezetben az x + x kifejezés és az (1 + 1) + (1 + 1) kifejezés jelentése közt nincs különbség. Ellenpélda: Legyen a környezet {x = random (0, 1)}, ahol random (a, b) egy a és b közötti véletlen szám egyenletes eloszlással. Legyen a kifejezés x + x és legyen a változó x. Ekkor az x + x kifejezés jelentése nem azonos a random (0, 1) + random (0, 1) kifejezés jelentésével 1, azaz ebben az összefüggésben nem teljesül a hivatkozások behelyettesíthetősége. Úgy is tudjuk cáfolni a hivatkozások behelyettesíthetőségét, hogy találunk egy e kifejezést amire az e e egyenlőségvizsgálat értéke hamis lesz. Mivel random (0, 1) random (0, 1) általában hamis, így ezért sem teljesül a hivatkozások behelyettesíthetősége. A doktori értekezésben tisztán funkcionális programozási nyelvnek nevezem az olyan programozási nyelvet, amelyben teljesül a hivatkozások behelyettesíthetősége, vagy egyszerű feltétel adható a hivatkozások behelyet- 1 A 2 random (0, 1) egy 0 és 2 közötti véletlen szám egyenletes eloszlással, ezzel szemben a random (0, 1) + random (0, 1) eloszlása nem egyenletes, az 1 körüli számok a legvalószínűbbek. 13
16 tesíthetőségére. A definíció alapján tisztán funkcionális nyelvek például a Haskell, a Clean 2 és a Miranda. A hivatkozások behelyettesíthetőségének definíciójában a kifejezés jelentése fogalom külön magyarázatra szorul. Általában egy kifejezés jelentése alatt a kifejezés funkcionális viselkedését értjük. A funkcionális viselkedésbe nem tartozik bele a futási idő vagy a memóriahasználat, de beletartozik például az, hogy a program adott bemenetre milyen kimenetet ad. A hivatkozások behelyettesíthetősége tehát nem azt jelenti, hogy a behelyettesítés során változatlan marad a program minden tulajdonsága. Ezt a tényt használjuk ki a tisztán funkcionális programok optimalizálásakor. Az hivatkozások behelyettesítésével kapott optimalizációs lépések csak nagyon korlátozottan alkalmazhatók olyan nyelvek esetén, ahol a hivatkozások behelyettesíthetősége komplex feltételhez kötött (például imperatív nyelvekben). A hivatkozások behelyettesíthetőségének előnyei: egyszerűbb programhelyesség bizonyítás, például egyenlőségi érvelés használata, kódoptimalizálási lehetőségek, parciális kiértékelés fordítás közben, nagyobb szabadság a kiértékelési stratégia megválasztásában, párhuzamos kiértékelés lehetősége Kapcsolódó fogalmak Van több szorosan kapcsolódó fogalom, amik általában a hivatkozások behelyettesíthetőségével egy időben teljesülnek. Ezekre a fogalmakra nem lesz szükségünk, de megemlítjük őket, hogy érzékeltessük a hivatkozási helyfüggetlenség fogalom fontosságát: Hivatkozási helyfüggetlenség (definiteness) Egy változó a hatókörén belül mindenhol ugyanazt a dolgot jelenti. Például a 3 x x + 17 kifejezésben az x mindkét helyen ugyanazt az értéket jelöli. 2 A Cleanben a hivatkozások behelyettesíthetőségét az egyszeres hivatkozásra vonatkozó típusozási szabályok korlátozzák. 14
17 Függvénydefiníciók behelyettesíthetősége (unfoldability, β-reduction) Egy függvényalkalmazás kicserélhető a függvény törzsére. Például, ha f (x) = x + x, akkor a 2 f (1 + 1) kifejezés helyett használhatjuk a 2 ((1 + 1) + (1 + 1)) kifejezést. Egyenlők behelyettesíthetősége (Leibniz s law, substitutivity of identity) Ha a=b, akkor ez a két kifejezés tetszőleges környezetben felcserélhető. Perzisztencia (persistence) A hivatkozás értéke nem változik meg műveletvégzéskor. (Perzisztencia alatt az értekezésben mindig teljes perzisztenciát értünk.) Kiterjeszthetőség (extensionality) Egy kifejezésről mindent elmond az értéke. Determinisztikusság (determinacy) Egy kifejezésnek mindig ugyanaz az értéke. Mellékhatásmentesség (lack of side effects) Kifejezés nem jár mellékhatással. kiértékelése Ezeknek a fogalmaknak az egymáshoz való viszonyát például a [28] cikk tárgyalja Kihívások a hivatkozások behelyettesíthetősége esetén A hivatkozások behelyettesíthetősége számos előnnyel jár, de következő feladatok kihívást jelentenek a hivatkozások behelyettesíthetőségének betartásakor: nem determinisztikus programok írása, véletlen számok használata, értékadás, változók és referenciák hatékony megvalósítása, destruktív módosítás, például tömbök hatékony használata, programszálak közti kommunikáció, I/O műveletek: adatbázis kezelés, fájlkezelés, hálózati kommunikáció, kommunikáció a felhasználóval. 15
18 Ezekre a kihívásokra több megoldás is létezik; a három legismertebb tisztán funkcionális nyelv, a Miranda, a Clean és a Haskell nyelv három alapvetően különböző megoldást talált. A Haskell megoldását a 3.10 fejezetben, a Clean megoldását a 4.6 fejezetben tárgyaljuk Referenciák megvalósítása A doktori értekezésben a referenciák kiváltásának kérdésével foglalkozom tisztán funkcionális nyelvekben, ami viszont kapcsolatba hozható az előző felsorolás többi kihívásával is. A következő kód megmutatja, hogy miért problematikus a hivatkozások behelyettesíthetősége referenciák használta esetén. let r = newref 4 x = readref r in writeref r 5 return (x + readref r) Az lenne a legkevésbé meglepő ha a 9 értéket kapnánk eredményül, viszont az x hivatkozás behelyettesítése után viszont az lenne a legkevésbé meglepő, ha a 10 értéket kapnánk eredményül: let r = newref 4 in writeref r 5 return (readref r + readref r) A két kódnak azonosnak kellene lennie ha teljesül a hivatkozások behelyettesíthetősége, viszont a két kód azonossága nehezen teljesíthető, mivel különböző végeredményt várunk el tőlük. Nem állítom, hogy a szemantika módosításával nem lehetséges összeegyeztetni a referenciák használatát a hivatkozások behelyettesíthetőségével, viszont a doktori értekezésben nem a programozási nyelvek szemantikájának módosításával kívánok eredményt elérni, hanem az ismert szemantikák mellett újabb programnyelvi konstrukciók bevezetésével. 16
19 2.3. Megoldások összefoglalása Tisztán funkcionális nyelvekben a következő lehetőségeket azonosítottam amikkel referenciák kiválthatók: 1. Tisztán funkcionális adatszerkezetek használata Rövid leírás A véges leképezés adatszerkezettel jól modellezhetők a referenciák. Előnyök A programozónak nagy szabadsága van, mivel a tisztán funkcionális adatszerkezetek perzisztensek. Lehetőség van például az összes referencia értékének egy adott időpontban való megjegyzésére és későbbi visszaállítására. Hátrányok A perzisztencia lehetetlenné teszi az adatszerkezetek destruktív módosítását, ami kizár sok hatékony implementációs lehetőséget. Például a (perzisztens) véges leképezés elemi műveleteinek hatékonysága csökken az elemszám növekedésével. Felhasználás az értekezésben Definiáltam egy módosított véges leképezés adatszerkezet, ami hatékony bizonyos természetes feltételek mellett, amik teljesülnek ha referenciák modellezésére használjuk a leképezéseket. Erről szól az első tézis (6). 2. A műveletek mellékhatásának elkülönítése Ha elkülönítjük a mellékhatásos kifejezéseket a mellékhatásmentesektől, akkor biztonságosan ki tudjuk használni a hivatkozások behelyettesítésének az előnyeit legalább a mellékhatásmentes kifejezések esetén. A mellékhatások elkülönítésének módjai: (a) programhelyesség bizonyítással Rövid leírás A programhelyesség bizonyítás során minden információ rendelkezésre áll ahhoz, hogy a kifejezések mellékhatásait vizsgáljuk. A referencia műveletek mellékhatásának elkülönítésére például a szétválasztási-logika [26] (angolul separation logic) használható. Előnyök A programkód egyszerű marad, mert mellékhatásokra vonatkozó információ a programra vonatkozó állításokban és bizonyításokban van. 17
20 Hátrányok A hivatkozások behelyettesíthetősége komplex feltételhez kötött, ami többnyire a programkódtól elkülönítve jelenik meg, ezért a mellékhatások elkülönítése programhelyesség bizonyítással nem tekinthető a tisztán funkcionális programozás eszközének. A helyességbizonyítás során kapott információ nehezen vehető igénybe a program fordításakor, például optimalizáció céljából. Ha a szétválasztási logikát a típusrendszerrel fejezzük ki, akkor a mellékhatás-típusozással kapcsolatos hátrányok jelentkeznek. Felhasználás az értekezésben Ezzel a módszerrel nem foglalkozok az értekezésben, mert a mellékhatások elkülönítését programhelyesség bizonyítással nem tekintem a tisztán funkcionális programozás eszközének. (b) mellékhatás-típusozással Rövid leírás A mellékhatás-típusozás (angolul effect-typing, 5.4. fejezet) a kifejezések mellékhatásait a típusrendszer segítségével követi. Előnyök A programkód egyszerű marad, mert mellékhatásokra vonatkozó információ a típusban van, ami esetleg automatikusan ki is következtethető. Hátrányok A hivatkozások behelyettesíthetősége komplex feltételhez kötött, ami csökkenti a hivatkozások behelyettesíthetőségéből származó előnyöket, például nehezebb egyenlőségi érvelést végezni. A mellékhatás-típusozási rendszerek meglehetősen komplexek, a nem mohó kiértékelési stratégiák különösen nehezen kezelhetőek. Felhasználás az értekezésben Bizonyos mellékhatások esetében egyszerű feltétel adható a hivatkozások behelyettesítéséhez, például referenciák egyenlőségvizsgálata esetén. Ekkor a mellékhatás-típusozás vagy hasonló módszer egyszerűen használható marad; ezt mutatom be a harmadik tézisben (8). (c) egyediségi típusozással Rövid leírás Az egyediségi típusozás (4.6. fejezet) a mellékhatás-típusozás egy egyszerűsített változatának tekinthető, ahol az egyetlen lehetséges mellékhatás az, 18
21 hogy egy értéket egy művelet során már felhasználtunk, és ezzel a mellékhatással fejezünk ki minden más mellékhatást. Előnyök A kód olvasásakor például egyenlőségi érvelés esetén a hivatkozások behelyettesíthetőse feltétel nélkül alkalmazható. A programkód egyszerű marad, mert a mellékhatásokra vonatkozó információ a típusban van, ami automatikusan kikövetkeztethető. Hátrányok A hivatkozások behelyettesíthetősége komplex feltételhez kötött programírás például programtranszformáció esetén. A típusrendszert alkalmassá kell tenni az egyediségi típusozásra, ami típusattribútumokkal történhet. Felhasználás az értekezésben A második tézisben (7) az egyediségi típusozás egy egyszerűsített változatát használom a referencia műveletek mellékhatásának elkülönítésére. (d) monádokkal Rövid leírás A monádok (3.11. fejezet) a mellékhatást a programkódban explicit módon jelzik, és megadják, hogy a részkifejezések mellékhatásából hogyan számítható ki az egész kifejezés mellékhatása. Előnyök A hivatkozások behelyettesíthetősége feltétel nélkül alkalmazható. A monádok nem igényelnek speciális típusozást, a monadikus műveleteknek típusa típuskonstruktorokkal és univerzális kvantálással leírható. Hátrányok A mellékhatásokat a programkódban is jelezni kell, és előfordul hogy ugyanannak az algoritmusnak meg kell adni egy mellékhatásokat kezelő és nem kezelő változatát is. A hivatkozások behelyettesíthetősége teljesül ugyan, de a monádok használata indokolatlanul rögzítheti a kiértékelési sorrendet, így a helyességbizonyítás lépései kötöttebbek lesznek, valamint fordítóprogramnak kevesebb tere marad az optimalizációra, ami érdekes módon pont a hivatkozások be nem helyettesíthetőségének egy tünete. Egymástól független mellékhatások kezelése monádokkal nehézkes. Felhasználás az értekezésben A referenciák monádokkal 19
22 való megvalósítása már kidolgozott, amit az 5.2 fejezetben mutatok be. Összegzésképpen elmondható, hogy mind a négy módszernek 3 megvan az előnye és a hátránya is, és az alkalmazáshoz igazodva érdemes a leginkább megfelelő módszert kiválasztani. 3 A mellékhatások elkülönítését programhelyesség bizonyítással nem tekinthető a tisztán funkcionális programozás eszközének, így négy módszer marad. 20
23 3. Bevezetés a tisztán funkcionális programozásba A doktori értekezésben a Haskell nyelv szintaxisát és szemantikáját használom; a későbbi fejezetekben definiált interfészeket és azok implementációját, valamint a felhasználási példákat is Haskell nyelven adom meg A Haskell modulrendszere A Haskell nyelv definíciós és fordítási egysége a modul. Minden Haskell modul egy szövegfájl, ami az alábbi részekből áll, kötött sorrendben. fejléc: modul modulnév where A modulnév hierarchikus felépítésű, mint például System.IO.Error. A modulnévnek összhangban kell lenni a modulnak a fájlrendszerben való elhelyezkedésével, például a Data.Map modulnak a Data könyvtár Map.hs szövegfájljában kell elhelyezkednie. export lista A modulok különböző azonosítókat exportálhatnak, például függvény- és típusazonosítókat. A nem exportált azonosítók csak a modulon belül láthatóak. import lista Itt soroljuk fel, hogy a modul milyen egyéb modulokat importál. Körkörös importálás lehetséges, de nem ajánlott a használata. Az importált modulok exportált azonosítói láthatóak lesznek a modulon belül, és akár tovább is exportálhatóak. deklarációk A deklarációk sorrendje a Haskell nyelvben nem számít. Az deklarációk típusai (ezeket a következő alfejezetekben mutatjuk be részletesen): Konstansdefiníció: pi = 2 acos 0 Függvénydefiníció: f x = x Speciális függvénydefiníciók: 21
24 Operátor definíció: a b = (a > b) Az operátorok kétparaméteres függvények speciális szintaxissal. A konstansok nulla paraméterű függvényeknek tekinthetők. Típusdeklaráció: f :: Int Int Típusdefiníció Típus szinonima definíció: type String = [ Char] Algebrai adattípus definíció: data Bool = True False Típusosztály definíció: class Num a where... Típusosztály példány definíció: instance Num Int where... A modul fejléc, az importálás és az exportálás szintaxisával és pontos szemantikájával nem foglalkozunk, mivel ezek nem szükségesek a doktori értekezés megértéséhez. A modulok programokat és programkönyvtárakat alkotnak, amik csomagokban terjeszthetők. Minden programban szerepelnie kell egy legfelső szintű modulnak. A legfelső szintű modul áttételesen importálja az összes többi modult, és exportálja a main azonosítót, ami lefordított program belépési pontja lesz. Programkönyvtárakra nincs semmilyen megkötés, ezek egyszerűen modulok halmazai. A csomagok közt is van egy függőségi reláció, ami nem lehet körkörös. A legfontosabb csomag a base, ami tartalmazza a Prelude nevű modult is. A Prelude modul sok alapvető definíciót tartalmaz és automatikusan importált minden modulba, hacsak külön nem kérjük ennek az ellenkezőjét Lexikális elemek A következő lexikális elemeket fogjuk használni: Egysoros megjegyzés: -- megjegyzés Az egysoros megjegyzés a sor végéig tart. Literál 22
25 Decimális egész szám literál: 123,... Decimális tört szám literál: 1.23,... Unikód karakter literál: x, é,?,... Szöveg (sztring) literál: "szöveg",... Speciális karakter (){}[] ";, Kulcsszó data, type, class, instance, infix, infixl, infixr, where, case, of, do, let, in, =,, ::,,, Azonosító Kis kezdőbetűs alfanumerikus azonosító: length, f, f, x1,... Ezeket függvény- és változónévként használjuk. Nagy kezdőbetűs alfanumerikus azonosító: Bool, True,... Ezeket típuskonstruktor- és konstruktornévként használjuk. Grafikus karakterekből álló azonosító: +,,,,,... Ezeket operátornévként használjuk Kifejezések A szám, karakter és szöveg literálokon kívül a következő módokon készíthetünk kifejezéseket Függvényalkalmazás A függvényalkalmazás jele a szóköz: sin 0.5 A függvényalkalmazás balra köt, azaz (min 5 2) esetén a min függvénynek átadjuk az 5 paramétert, majd az eredmény függvénynek (amely minden számnak veszi az 5-tel való minimumát) átadjuk a 2 paramétert. A többparaméteres függvények szokásos reprezentációja a Haskellben egyparaméteres függvényekkel történik, amit körrizésnek hívunk. Erre mindig van lehetőség, mert az ((A B) C) függvénytér izomorf az (A (B C)) függvénytérrel. A kiértékelési sorrend megváltoztatásához a szokásos módon zárójeleket használunk: abs (sin 2) Az (abs sin 2) jelentése ((abs sin) 2) ami típushibás kifejezés. 23
26 Operátorok alkalmazása A +,,,/, operátorok kötési erőssége a szokásos, így például ( ) jelentése (3 ((5 2) 4)). A +,,, / operátorok balra kötnek, a hatványozás operátor pedig jobbra köt, azaz például ( ) jelentése ((1 1) (2 (2 2))). A függvényalkalmazás erőssebb minden operátornál, így például (sin ) jelentése ((sin 1.1) + 1). Operátorokat használhatunk prefix jelölésmóddal is, például ((+) 1 2) jelentése (1 + 2). Kétparaméteres függvényeket pedig használhatunk operátorként is, például (1 mod 2) jelentése (mod 1 2). Az úgynevezett szeletekkel az operátor egyik paraméterének elhagyásával képezhetünk függvényt. Például ( 2) a négyzetre emelés, (2 ) a 2 hatványára emelés függvénye N-esek Az n-esek segítségével különböző típusú kifejezéseket sorolhatunk fel egymás mellett (a típusozásról később lesz szó). Az n-esek alkalmasak például rekordok helyettesítésére, így például abban az esetben amikor egy függvény többféle végeredményt ad vissza nem szükséges egy külön adatszerkezetet definiálnunk a függvény végeredményének. Példák párokra: (1, c ), (3 + 2, True),... Példák hármasokra: (1, c, True), Listák A listák különböző számú, azonos típusú kifejezés felsorolására alkalmas (a típusozásról később lesz szó). Az üres lista jele: [ ]. Példák nem üres listákra: [1, 1 + 1, 3], [True], [ a, b ],... A szövegek (sztringek) karakter listák: "abc" ugyanaz, mint [ a, b, c ]. Az úgynevezett pont-pont kifejezések segítségével számtani sorozatokat rövidíthetünk: 24
27 [1.. 4] ugyanaz, mint [1, 2, 3, 4]. [1, ] ugyanaz, mint [1, 3, 5, 7, 9]. [1..] az összes pozitív egész szám listája (a végtelen listákról később lesz szó). [1, 3..] az összes páratlan szám listája. A halmazkifejezések segítségével összetett listákat adhatunk meg tömören. Itt csak néhány példát mutatunk: A 2 hatványai növekvő sorrendben: [2 n n [1..]] A négyzetszámok növekvő sorrendben: [n 2 n [1..]] A 60 osztói: [n n [1.. 60], mod 60 n 0] A dominók reprezentálása párokkal: [(n, m) n [0.. 9], m [0.. 9], n m] vagy másképpen [(n, m) n [0.. 9], m [n.. 9]] A listák az üres listából és a (:) konstruktor alkalmazásából épülnek fel, ahol (:) egy elemet ad a lista elejéhez. Például [ 2, 3, 4] egy rövidített jelölés a 2 : 3 : 4 : [ ] kifejezésre. A legfontosabb függvények listákon: lista hossza: (length [3, 4]) értéke 2, listák összefűzése: [1, 2] + [3, 4] értéke [1, 2, 3, 4]. hajtogatás: foldr f e xs az xs listában kicseréli a (:) konstruktort f-re és a [ ] konstruktort e-re. Például foldr (+) 0 (1 : 2 : 3 : [ ]) = Érdekesség, hogy a hajtogatással minden listán értelmezett függvény leírható, például xs + ys = foldr (:) ys xs. A balról hajtogatás, foldl a megfordított listán hajtogat. 25
28 3.4. Függvénydefiníciók Egyszerű függvény- és konstansdefiníciók Egyszerű függvénydefiníció szintaxisa: függvénynév változónevek = kifejezés A kifejezés hivatkozhat a változókra. Például a következő függvény megállapítja hogy egy év szökőév-e (a logikai vagy operátor gyengébben köt, mint a logikai és operátor): isleapyear n = n mod 4 0 n mod n mod Másik példa: a következő többparaméteres függvény megállapítja, hogy három valós szám lehet-e valamely háromszög három oldalának oldalhossza: aretrianglesides x y z = x + y > z y + z > x z + x > y Konstans definiálásakor nem adunk meg egy változónevet sem: pi = 4 atan 1 Operátorok definiálásakor már az egyenlőségjel bal oldalán is infix jelölésmódot használunk: x z = (x y) Az operátorok kötési erősségét is megadhatjuk: infix 4 Ha infix helyett az infixl vagy infixr kulcsszavakat használjuk akkor az operátor balra illetve jobbra kötő lesz Mintaillesztés A mintaillesztés során a függvényt úgy definiáljuk, mintha látnánk, hogy a függvényt milyen paraméterrel hívták meg. Például a logikai tagadás definíciója Haskellben: :: Bool Bool True = False False = True 26
29 A függvény egyes definícióit függvényágaknak nevezzük, az előző függvénynek például két ága van. Fontos tudnivaló, hogy nem vizsgálhatunk tetszőleges kifejezést az egyenlőségjel bal oldalán. Például a következő definíciót nem fogadja el a Haskell: :: Bool Bool ( x) = x -- hibás True = False False = True Azokat a kifejezéseket, amik szerepelhetnek az egyenlőségjel bal oldalán a függvény neve mögött, mintának nevezzük. A minták nem részhalmazai a kifejezéseknek, van olyan minta is amit nem használhatunk kifejezésként. Kifejezések amelyek minták is: változók: x, xs, y, a,... A változó minta bármire illeszkedik, és az egyenlőségjel jobb oldalán a változóval tudunk hivatkozni az illesztett értékre. úgynevezett konstruktor alkalmazások: True, 0, (a, b),... Minták amelyek nem kifejezések: joker minta: A joker minta bármire illeszkedik. Az illesztett értékre nem tudunk hivatkozni. Akkor használunk joker mintát, ha az illesztett adat nem vesz részt a végeredmény kiszámolásában. összefogó minta: v@p ahol v változó, p minta. Az összefogó minta esetén amellett hogy mintaillesztést végzünk a p minta szerint, az illesztendő kifejezést kötjük is a v változóhoz. A joker alkalmazására példa a logikai ÉS definíciója: True x False = x = False Ha az függvényágak nem zárják ki egymást akkor lényeges a függvényágak sorrendje. Ha több függvényág is illeszkedik, akkor az első illeszkedő függvényág határozza meg a végeredményt. Például a következő definíció is helyes: 27
30 True x = x = False Konstruktor alkalmazásoknak számítanak a következő kifejezések: szám, karakter és szöveg literálok, a logikai értékek két konstruktora, a True és a False, párok mintái: (x,y) alakú kifejezések ahol x és y tetszőleges minta; hasonló a helyzet hármasok, négyesek stb. esetén, az üres lista [ ], véges hosszúságú listák, például három elem esetén [x,y,z] ahol x, y és z minták, elem hozzáadása a lista elejéhez (x:xs) ahol x és xs minták. Például a következő rekurzív függvény összegzi egy lista elemeit: sum [ ] = 0 sum (x : xs) = x + sum xs Gyakori példa a funkcionális gyorsrendezés is: qsort [ ] = [ ] qsort (x : xs) = qsort [y y xs, y < x] + [x] + qsort [y y xs, y x] Az összefogó mintára egy példa f xs@( H : _) = xs f = [ ] ahol f a H karakterrel kezdődő listákon identikus függvényként viselkedik, a többi listához pedig az üres listát rendeli. Esetszétválasztást végezhetünk kifejezéseken belül is a case konstrukcióval. Az előző f függvény például így is írható: f xs = case xs of ( H : _) xs; [ ] Megjegyezzük, hogy konstansdefiníció esetében a konstans neve helyett szerepelhet tetszőleges minta. Például (x : xs) = [1..] esetén x értéke 1 lesz, xs értéke pedig [2..] lesz. 28
31 Esetszétválasztás Az úgynevezett esetszétválasztás nagyon hasonlít a matematikai esetszétválasztásra. Például a minimum függvény definíciója { x ha x y, min(x, y) = y egyébként. ami Haskellben a következőképpen adható meg: min x y x y = x otherwise = y Az eltérések a matematikai jelölésmódtól: a kapcsos zárójel helyett függőleges vonalak vannak, a feltételek és az eredmények oszlopa fel van cserélve, a feltételek és az eredmények közt vessző helyett ott van az egyenlőségjel. Az esetek sorrendje számít, az első igaz feltételű eset határozza meg a végeredményt. Megjegyezzük hogy az otherwise nem kulcsszó, hanem a Prelude modulban definiált konstans: otherwise = True Példaként megmutatjuk még a gyorshatványozást ahol egyszerre használunk mintaillesztést és esetszétválasztást: x 0 = 1 x n even n = sqr (x (n div 2)) otherwise = x x (n 1) sqr x = x x even a Prelude-ben definiált függvény. 29
32 Lokális definíciók Lokális definíciókat függvény- vagy konstansdeklarációkhoz a where kulcsszóval tudunk bevezetni. A where hatóköre addig terjed, amíg a behúzás tart. A következő függvény az n-edik pozíciónál kettévág egy listát (0-tól számolva): splitat n xs n 0 = ([ ], xs) splitat n [ ] = ([ ], [ ]) splitat n (x : xs) = (x : as, bs) where (as, bs) = splitat (n 1) xs A lokális definíciós blokkban itt egy konstansdefiníció szerepel ami egy minta segítségével köti a rekurzív splitat hívás végeredmény párjának két elemét. Figyeljük meg, hogy ha az splitat első függvényágának egyetlen esetszétválasztásos esete nem teljesül, akkor a többi függvényág határozza meg a végeredményt. Lokális definíció nem csak deklarációkhoz kapcsolható, hanem tetszőleges kifejezéshez is. Ekkor a következő szintaxist használjuk: let minta = kifejezés in kifejezés Például a [0, 1, 2] + let xs = [3, 4, 5] + xs in xs kifejezés értéke [0, 1, 2, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5..] lesz Magasabbrendű függvények Magasabbrendű függvénynek nevezzük az olyan függvényeket amik függvényt várnak vagy függvényt ad vissza. (A körrizés miatt minden többparaméteres függvény is függvényt ad vissza de csupán emiatt ezeket nem szokás magasabbrendű függvényeknek nevezni.) A magasabbrendű függvényekhez nem kapcsolódik speciális szintaxis, ugyanúgy definiálandók mint minden más függvény. A filter függvény egy adott feltétel szerint szűri a lista elemeit. A feltétel egy logikai értékű függvény, amit meghívunk az esetszétválasztáskor: 30
33 filter p [ ] = [ ] filter p (x : xs) p x = x : filter p xs otherwise = filter p xs A magasabbrendű függvények jól használhatók szeletekkel, például (filter ( 4) [1.. 9]) értéke [1, 2, 3, 5, 6, 7, 8, 9]. A magasabbrendű függvények szintén jól használhatók úgynevezett névtelen függvényekkel. A névtelen függvény szintaxisa: λ minta kifejezés. A kifejezés hivatkozhat a mintában definiált változókra. A névtelen függvény egy függvény értékű kifejezés. Például (filter (λx x < 4 x > 6) [1.. 9]) értéke [1, 2, 3, 7, 8, 9]. A függvénykompozíció is egy magasabbrendű függvény, amit névtelen függvény segítségével definiálunk: f g = λx g (f x) 3.6. Szigorú statikus típusozás A Haskell szigorúan és statikusan típusos nyelv. A szigorú és statikus típusozás szerepe: a futási idejű hibák minél nagyobb részének a fordítási időbe való áthelyezése, kódoptimalizációs lépések lehetővé tétele, a programozó bizonyos, a kóddal szembeni elvárásainak kifejezhetővé tétele, és ezzel a fordítóprogram által ellenőrzött dokumentáció biztosítása. A Haskell típusrendszere a Hindley-Milner típusrendszerre épül. Néhány példával szemléltetjük a típusrendszer lehetőségeit. A Haskell a következő típusokat támogatja: elemi típusok A preludeben definiált néhány elemi típus: 31
34 Bool: két értéke van a True és a False Char: unikód karakterek típusa Int: korlátos egész számok típusa. A korlát általában Integer: egész számok típusa (bignum) Float, Double: egyszeres és kétszeres pontosságú lebegőpontos számok típusa A típust a :: jel után adjuk meg. Például True :: Bool x :: Char összetett típusok függvénytípus x y az x értelmezési tartományú és y értékkészletű függvények típusa. Például isalpha :: Char Bool ( ) :: Bool Bool Bool A operátor jobbra köt, azaz ( ) :: Bool (Bool Bool), ahogy a körrizés említésekor láttuk. listatípus [x], az x típusú elemeket tartalmazó listák típusa (minden elemnek azonos típusúnak kell lennie). Például [True, False] :: [Bool] [[ ], [True, False]] :: [[Bool]] n-es típus A párok típusa (x, y), ahol x a pár első elemének, y a pár második elemének típusa. Például ([True], [ x, y ]) :: ([Bool], [Char]) [(True, x ), (False, y )] :: [(Bool, Char)] Hasonló a hármasok, négyesek stb. típusa. univerzális polimorfizmus A típusban szerepelhetnek típusváltozók, amik univerzálisan kvantáltak, azaz tetszőleges típusra kicserélhetőek. Például length :: [a] Int azaz length specializálható például a [ Char] Int típusra. A specializálást a típusellenőrző automatikusan végzi. Például length [ True] esetén a típusváltozó értéke Bool lesz. 32
35 esetleges polimorfizmus Az univerzális polimorfizmushoz hasonló, de lehetőség van a típusváltozó lehetséges értékeinek a megszorítására. A Prelude-ben definiált néhány megszorítás (más néven típusosztály, lásd később): Num a: a lehet szám típus, például Int, Integer, Float, Double. Integral a: a lehet egész szám típus, például Int, Integer. Integral a magában hordozza a Num a megszorítást is. Eq a: az a típusra van egyenlőségvizsgálat Ord a: az a típusra van összehasonlítás művelet Ord a magában hordozza az Eq a megszorítást is. Show a: az a típus értékeket szöveggé lehet alakítani A megszorításokat egy n-esben kell elhelyezni a típus elején, a operátor előtt. Példák: even :: Integral a a a ( ) :: (Integral b, Num a) a b a max :: Ord a a a a 113 :: Num a a Vegyük észre, hogy a Haskellben vannak polimorf literálok és konstansok is. Megemlítjük, hogy a Haskellben nincs implicit típuskonverzió; minden típuskonverzió explicit, de ilyenre viszonylag ritkán van szükség. Például (even 113) esetén a 113 az alapértelmezett Integral típussal jön létre, így nincs szükség konverzióra az even alkalmazásakor. A Haskell automatikus típuskikövetkeztetést végez, azaz a függvények és kifejezések típusát nem kell megadnunk. A függvények típusát azonban célszerű megadni dokumentációs célból. Példaként nézzük meg újra a függvénykompozíció definícióját, ezúttal típusdeklarációval együtt: ( ) :: (b c) (a b) (a c) f g = λx g (f x) 33
36 3.7. Típusdefiníciók A Haskell típusrendszere kibővíthető típusdefiníciók segítségével Típus szinonima definíciók A típus szinonimák segítségével összetett típusnak adhatunk nevet. A Preludben például a következő definíció szerepel, ami a szövegeket karakter listákként definiálja: type String = [Char] Lehetőség van paraméteres szinonimák definiálására is: type PredicateOn a = a Bool Példa a PredicateOn használatra: isalpha :: PredicateOn Char isalpha c = Algebrai adattípusok Az algebrai adattípussal új típust hozhatunk létre. Meg kell adnunk a típus nevét és az adatkonstruktorokat. A típus nevét típuskonstruktornak is nevezzük. Az adatkonstruktorokat függőleges vonallal választjuk el egymástól. A Bool típus definíciója a Prelude-ben: data Bool = True False Külön figyelmet érdemel a következő típus: data Void = Void Ez a típus előre definiált, de speciális szintaxissal: () az azonosítója a típusés az adatkonstruktornak is, és ezt nullásnak nevezzük. A nullást más 34
37 típusok paraméterekét használjuk, amikor nincs szükségünk különböző értékekre. Például a természetes számok egyik lehetséges reprezentációja a [()] típus (nullások listája). A konstruktoroknak lehetnek paramétereik is, mint például a Just konstruktornak a következő definícióban: data MaybeBool = Nothing Just Bool Ekkor a Just konstruktor típusa Bool MaybeBool lesz. A típuskonstruktornak is lehetnek paraméterei, ezek kötelezően típusváltozók, mint például a Maybe típuskonstruktornak az a típusváltozó: data Maybe a = Nothing Just a Ekkor a Just konstruktor típusa a Maybe a lesz. A Maybe típust sokszor használjuk az értekezésben; a segítségével egy kivételes érték adható hozzá bármely típushoz. A konstruktorokból és változókból álló kifejezések minták, azaz szerepelhetnek a függvénydefiníciók bal oldalán. Az alábbi függvény egy függvényt alkalmaz a Maybe x értéken: fmap :: (x y) Maybe x Maybe y fmap f Nothing = Nothing fmap f (Just a) = Just (f a) A következő típus nem más mint a pár típus, csak más szintaxissal: data Pair a b -- (a, b) = Pair a b -- (a, b) Az algebrai típus lehet rekurzív is. A következő típus nem más, mint a lista típus, csak más szintaxissal: data List a -- [a] = Nil -- [] Cons a (List a) -- a : as A Cons típusa például a List a List a, és megfelel a (:) operátornak. 35
38 A Haskell típusellenőrző valóban nem kezeli speciálisan az n-eseket és a listákat, ezeknek csak a szintaxisa speciális. Például az [ 12, 13] kifejezést a fordító a 12:13:[ ] kifejezésként értelmezi. Ez is mutatja hogy az algebrai típusok kifejezőereje milyen nagy. Rekordok. Az algebrai adattípus konstruktor paramétereinek nevet is adhatunk, ekkor rekordról és rekordmezőkről beszélünk: data Pair a b = Pair {fst :: a, snd :: b } A rekordnak név szerint is megadhatjuk a paramétereit: Pair {fst = 1, snd = True}. A Haskellben a rekordmezőkből automatikusan mezőkiválasztó függvények készülnek, például az fst típusa Pair a b a lesz Absztrakt típusok Absztrakt típusról beszélünk, ha a típus reprezentációja rejtett. Az absztrakt típusok előnye, hogy a típus reprezentációja átfogalmazható a típust használó kódok átfogalmazása nélkül. Ha azt kívánjuk jelölni, hogy egy típus absztrakt, akkor a következő jelölésmódot használjuk: data Tree a Tree a egy egyparaméteres absztrakt típus. Ez a szintaxis nem része a Haskell nyelvnek. A Haskellben a reprezentáció elrejtésére a modulrendszere használható: például egy algebrai típusdefiníció esetén exportáljuk a típuskonstruktort, de nem exportáljuk az adatkonstruktorokat Típusosztályok A típusosztályok szerepe a funkcionális nyelvekben nem más, mint a programkód algoritmikus kiegészítése a programozó által megadott szabályok szerint. A típusosztályok használatával a fordítóprogram képességeit 36
39 egészíthetjük ki, biztonságos és kényelmes módon. A típusosztályok jól használhatók beágyazott alkalmazásspecifikus nyelvek (EDSL) írásakor, és nagyban hozzájárulnak ahhoz, hogy a Haskell kiválóan alkalmas ilyen nyelvek írására. A típusosztályok típusvezérelt kódgenerálást tesznek lehetővé, emiatt is fontos hogy a Haskell típusrendszere minél nagyobb kifejezőerővel rendelkezzen (minél szigorúbb legyen) Típusosztályok definiálása Nézzük meg a Prelude-beli Show típusosztály (egyszerűsített) definícióját: class Show a where show :: a String A Show osztálynak egy a paramétere és egy show nevű metódusa van. A metódusnak nem adtunk definíciót; minden típusosztály példányban különböző definíciót adhatunk neki. Ha a kódban bárhol a show x kifejezést használjuk ahol x :: T, akkor a fordító kicseréli a show-t a Show T-n definiált példányában szereplő kódra, feltéve hogy talál megfelelő példányt. Ha a példány nem állapítható meg egyértelműen (például T polimorf), akkor maga a show x kifejezés is polimorffá válik, például show 114 :: (Show a, Num a) String esetén. A polimorf kifejezések fordítása úgynevezett könyvtár-transzformációval (dictionary) történik. A program belépési pontja (main) nem lehet polimorf. Példa osztálypéldányok megadására: instance Show Int show i =... where instance Show a Show [a] where show [ ] =... show (x : xs) =...show x... show xs... A Haskell típusosztályok erejét az adja, hogy a típusosztály példányok is lehetnek esetlegesen polimorfak, mint például a Show [ a] esetében, így minden listára egyszerre tudjuk a Show példányát definiálni. A fordító a megfelelő kódot generálja például a show [[1, 2], [ ]] kifejezéshez, holott az [[ Int]] típushoz nem adtunk meg példányt. 37
40 A típusosztályok közti hierarchia kialakítása úgy történik, hogy megszorításokat adunk meg az osztály (valamely) típusváltozójára az osztálydefinícióban: class Eq a where ( ) :: a a Bool class Eq a Ord a where (<) :: a a Bool 3.9. Dinamikus típusozás A Haskellben dinamikus típusozás is használható. A dinamikus típusú értékek statikus típusa közösen Dynamic. A dinamikus és a statikus típusozás közti átmenetet a következő függvények biztosítják: todyn :: Typeable a a Dynamic fromdynamic :: Typeable a Dynamic Maybe a A Typeable típusosztálynak az általánosan használt nem polimorf típusokra van példánya. fromdynamic a Nothing értékkel tér vissza, ha nem sikerült a típuskonverzió, így a használata biztonságos. Ha biztosan tudjuk, hogy a típuskonverzió a dinamikus típusról sikeres, akkor használhatjuk az Any típust is az unsafecoerce veszélyes típuskonverzióval (4.1. fejezet) Akciók A Haskellben az akciók használatával biztosítjuk hogy a mellékhatásos számítások ne veszélyeztessék a hivatkozások behelyettesíthetőségét. A kifejezések egy meghatározott csoportját akciónak nevezzük. Az, hogy a kifejezés akció-e, a kifejezés típusa alapján egyszerűen eldönthető. Két szintet különböztetünk meg a program futása során: A kifejezések kiértékelése során sosem történik mellékhatás. Az akciók végrehajtása lehet mellékhatásos. 38
41 Minél több lépés történik a kiértékelés során, és minél kevesebb lépés történik a végrehajtás során, annál inkább használható a hivatkozások behelyettesíthetősége. Elmondható, hogy egy tisztán funkcionális nyelven írt program annál inkább funkcionális stílusban íródott, minél kevesebb a benne a végrehajtás. A mellékhatásokat tehát a végrehajtási fázisra korlátozzuk, így biztosítjuk a hivatkozások behelyettesíthetőségét. A nem tiszta funkcionális nyelvekben a kiértékelési és a végrehajtási fázis egybemosódik, így elvesznek a hivatkozások behelyettesíthetőségének előnyei a kiértékelési fázisban Az akciók típusa A kiértékelés és a végrehajtás időben nem különül el egymástól, a Haskell típusrendszere viszont különbséget tesz köztük. Adott egy absztrakt adattípus: data IO a Az IO a típusú értékek mellékhatásos műveletek, amik a végrehajtás során egy a típusú eredményt adnak. Példák IO típusú kifejezésekre: getline :: IO String Az getline akció egy sort olvas be a konzolról az Enter billentyű leütéséig. a :: IO () Ha az a akciónak csak a mellékhatása lényeges, akkor egy nullással ( fejezet) tér vissza. f :: a IO b Az f egy mellékhatásmentes függvény ami akciót ad vissza. Például putchar :: Char IO () az a függvény, ami minden karakterhez hozzárendel egy akciót aminek a végrehajtása során a karakter kikerül a konzolra. a :: IO (IO Int) Az a akció egy akciót ad vissza. Ennek a konstrukciónak van értelme. Például a lehet egy akció, ami készít egy számlálót (egy Int típusú referenciát 0 kezdőértékkel), és visszaad egy olyan akciót, ami 39
FUNKCIONÁLIS PROGRAMOZÁS
FUNKCIONÁLIS PROGRAMOZÁS A funkcionális programozás néhány jellemzője Funkcionális programozás 1-2 Funkcionális, más néven applikatív programozás Funkcionális = függvényalapú, függvényközpontú Applikatív
RészletesebbenFUNKCIONÁLIS PROGRAMOZÁS GYAKORLAT JEGYZET
FUNKCIONÁLIS PROGRAMOZÁS GYAKORLAT JEGYZET Szerkesztette: Balogh Tamás 2013. május 17. Ha hibát találsz, kérlek jelezd a info@baloghtamas.hu e-mail címen! Ez a Mű a Creative Commons Nevezd meg! - Ne add
RészletesebbenFunkcionális Nyelvek 2 (MSc)
Funkcionális Nyelvek 2 (MSc) Páli Gábor János pgj@elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar Programozási Nyelvek és Fordítóprogramok Tanszék Tematika A (tervezett) tematika rövid összefoglalása
RészletesebbenKifejezések. Kozsik Tamás. December 11, 2016
Kifejezések Kozsik Tamás December 11, 2016 Kifejezések Lexika Szintaktika Szemantika Lexika azonosítók (változó-, metódus-, típus- és csomagnevek) literálok operátorok, pl. + zárójelek: (), [], {},
Részletesebben2018, Funkcionális programozás
Funkcionális programozás 6. előadás Sapientia Egyetem, Matematika-Informatika Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2018, tavaszi félév Miről volt szó? Haskell modulok, kompilálás a
Részletesebben2016, Funkcionális programozás
Funkcionális programozás 2. előadás Sapientia Egyetem, Műszaki és Humántudományok Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2016, tavaszi félév Miről volt szó? Programozási paradigmák: imperatív,
RészletesebbenJava II. I A Java programozási nyelv alapelemei
Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2008. 02. 19. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve az annak
Részletesebben2019, Funkcionális programozás. 2. el adás. MÁRTON Gyöngyvér
Funkcionális programozás 2. el adás Sapientia Egyetem, Matematika-Informatika Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2019, tavaszi félév Mir l volt szó? Követelmények, osztályozás Programozási
RészletesebbenFUNKCIONÁLIS PROGRAMOZÁS ELŐADÁS JEGYZET
FUNKCIONÁLIS PROGRAMOZÁS ELŐADÁS JEGYZET Szerkesztette: Balogh Tamás 2013. május 30. Ha hibát találsz, kérlek jelezd a info@baloghtamas.hu e-mail címen! Ez a Mű a Creative Commons Nevezd meg! - Ne add
RészletesebbenKifejezések. Kozsik Tamás. December 11, 2016
Kifejezések Kozsik Tamás December 11, 2016 Kifejezés versus utasítás C/C++: kifejezés plusz pontosvessző: utasítás kiértékeli a kifejezést jellemzően: mellékhatása is van például: értékadás Ada: n = 5;
RészletesebbenTulajdonságalapú tesztelés
Tulajdonságalapú tesztelés QuickCheck A QuickCheck Haskell programok automatikus, tulajdonságalapú tesztelésére használható. Programspecifikáció: program által teljesítendő tulajdonságok Nagy számú, a
RészletesebbenA szemantikus elemzés helye. A szemantikus elemzés feladatai. A szemantikus elemzés feladatai. Deklarációk és láthatósági szabályok
A szemantikus elemzés helye Forrásprogram Forrás-kezelő (source handler) Lexikális elemző (scanner) A szemantikus elemzés feladatai Fordítóprogramok előadás (A, C, T szakirány) Szintaktikus elemző (parser)
RészletesebbenS2-01 Funkcionális nyelvek alapfogalmai
S2-01 Funkcionális nyelvek alapfogalmai Tartalom 1. Funkcionális nyelvek alapfogalmai Modell Kiértékelés Curry-zés Magasabbrendű függvények Listák Tisztaság 2. Típusok Algebrai adattípusok Típusosztályok
RészletesebbenProgramozás II. 2. Dr. Iványi Péter
Programozás II. 2. Dr. Iványi Péter 1 C++ Bjarne Stroustrup, Bell Laboratórium Első implementáció, 1983 Kezdetben csak precompiler volt C++ konstrukciót C-re fordította A kiterjesztés alapján ismerte fel:.cpp.cc.c
RészletesebbenMemóriagazdálkodás. Kódgenerálás. Kódoptimalizálás
Kódgenerálás Memóriagazdálkodás Kódgenerálás program prológus és epilógus értékadások fordítása kifejezések fordítása vezérlési szerkezetek fordítása Kódoptimalizálás L ATG E > TE' E' > + @StPushAX T @StPopBX
RészletesebbenKészítette: Nagy Tibor István
Készítette: Nagy Tibor István A változó Egy memóriában elhelyezkedő rekesz Egy értéket tárol Van azonosítója (vagyis neve) Van típusa (milyen értéket tárolhat) Az értéke értékadással módosítható Az értéke
Részletesebbenés az instanceof operátor
Java VIII. Az interfacei és az instanceof operátor Krizsán Zoltán Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2005. 10. 24. Java VIII.: Interface JAVA8 / 1 Az interfészről általában
RészletesebbenJava VIII. Az interfacei. és az instanceof operátor. Az interfészről általában. Interfészek JAVA-ban. Krizsán Zoltán
Java VIII. Az interfacei és az instanceof operátor Krizsán Zoltán Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2005. 10. 24. Java VIII.: Interface JAVA8 / 1 Az interfészről általában
RészletesebbenJava II. I A Java programozási nyelv alapelemei
Java2 / 1 Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2009. 02. 09. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve
RészletesebbenGENERIKUS PROGRAMOZÁS Osztálysablonok, Általános felépítésű függvények, Függvénynevek túlterhelése és. Függvénysablonok
GENERIKUS PROGRAMOZÁS Osztálysablonok, Általános felépítésű függvények, Függvénynevek túlterhelése és Függvénysablonok Gyakorlatorientált szoftverfejlesztés C++ nyelven Visual Studio Community fejlesztőkörnyezetben
RészletesebbenFunkcionális és logikai programozás. { Márton Gyöngyvér, 2012} { Sapientia, Erdélyi Magyar Tudományegyetem }
Funkcionális és logikai programozás { Márton Gyöngyvér, 2012} { Sapientia, Erdélyi Magyar Tudományegyetem } http://www.ms.sapientia.ro/~mgyongyi ` 1 Jelenlét: Követelmények, osztályozás Az első 4 előadáson
RészletesebbenBevezetés a programozásba II. 5. Előadás: Másoló konstruktor, túlterhelés, operátorok
Bevezetés a programozásba II 5. Előadás: Másoló konstruktor, túlterhelés, operátorok Emlékeztető struct Vektor { int meret, *mut; Vektor(int meret); int szamlal(int mit); }; int Vektor::szamlal(int mit)
Részletesebben2019, Funkcionális programozás. 5. el adás. MÁRTON Gyöngyvér
Funkcionális programozás 5. el adás Sapientia Egyetem, Matematika-Informatika Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2019, tavaszi félév Mir l volt szó? a Haskell kiértékelési stratégiája
Részletesebben2018, Funkcionális programozás
Funkcionális programozás 3. előadás Sapientia Egyetem, Matematika-Informatika Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2018, tavaszi félév Miről volt szó? A Haskell programozási nyelv főbb
RészletesebbenOOP #14 (referencia-elv)
OOP #14 (referencia-elv) v1.0 2003.03.19. 21:22:00 Eszterházy Károly Főiskola Információtechnológia tsz. Hernyák Zoltán adj. e-mail: aroan@ektf.hu web: http://aries.ektf.hu/~aroan OOP OOP_14-1 - E jegyzet
RészletesebbenA C# programozási nyelv alapjai
A C# programozási nyelv alapjai Tisztán objektum-orientált Kis- és nagybetűket megkülönbözteti Ötvözi a C++, Delphi, Java programozási nyelvek pozitívumait.net futtatókörnyezet Visual Studio fejlesztőkörnyezet
RészletesebbenMár megismert fogalmak áttekintése
Interfészek szenasi.sandor@nik.bmf.hu PPT 2007/2008 tavasz http://nik.bmf.hu/ppt 1 Témakörök Polimorfizmus áttekintése Interfészek Interfészek kiterjesztése Eseménykezelési módszerek 2 Már megismert fogalmak
RészletesebbenTisztán funkcionális adatszerkezetek (folytatás)
Tisztán funkcionális adatszerkezetek (folytatás) FingerTree (intuíció) [2..26] FingerTree (intuíció) [3..26] FingerTree (intuíció) [4..26] FingerTree (intuíció) [5..26] FingerTree (intuíció) [6..26] FingerTree
RészletesebbenTisztán funkcionális adatszerkezetek
Tisztán funkcionális adatszerkezetek Bevezetés A hatékony adatszerkezetek általában... [..] language-independent only in the sense of Henry Ford: Programmers can use any language as they want, as long
RészletesebbenAlapok. tisztán funkcionális nyelv, minden függvény (a konstansok is) nincsenek hagyományos változók, az első értékadás után nem módosíthatók
Haskell 1. Alapok tisztán funkcionális nyelv, minden függvény (a konstansok is) nincsenek hagyományos változók, az első értékadás után nem módosíthatók elég jól elkerülhetők így a mellékhatások könnyebben
RészletesebbenProgramozási nyelvek (ADA)
Programozási nyelvek (ADA) Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 1. előadás Hasznos weboldal http://kto.web.elte.hu Program felépítése Programegységek (program unit) eljárások (procedure)
RészletesebbenS0-02 Típusmodellek (Programozás elmélet)
S0-02 Típusmodellek (Programozás elmélet) Tartalom 1. Absztrakt adattípus 2. Adattípus specifikációja 3. Adattípus osztály 4. Paraméterátadás 5. Reprezentációs függvény 6. Öröklődés és polimorfizmus 7.
RészletesebbenProgramozás burritokkal
Monádok (folytatás) Programozás burritokkal [2..21] Programozás monádokkal: Programstrukturálás type IO α = World (α, World) -- putstr :: String IO () -- getline :: IO String (>>=) :: IO α (α IO β) IO
RészletesebbenC++ referencia. Izsó Tamás február 17. A C++ nyelvben nagyon sok félreértés van a referenciával kapcsolatban. A Legyakoribb hibák:
C++ referencia Izsó Tamás 2017. február 17. 1. Bevezetés A C++ nyelvben nagyon sok félreértés van a referenciával kapcsolatban. A Legyakoribb hibák: Sokan összetévesztik a pointerrel. Keveset alkalmazzák
Részletesebben2018, Funkcionális programozás
Funkcionális programozás 10. előadás Sapientia Egyetem, Matematika-Informatika Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2018, tavaszi félév Miről volt szó? a foldl és foldr függvények lista
RészletesebbenOperációs rendszerek. 9. gyakorlat. Reguláris kifejezések - alapok, BASH UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED
UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED Reguláris kifejezések - alapok, BASH Operációs rendszerek 9. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Csuvik Viktor
RészletesebbenJava programozási nyelv 5. rész Osztályok III.
Java programozási nyelv 5. rész Osztályok III. Nyugat-Magyarországi Egyetem Faipari Mérnöki Kar Informatikai Intézet Soós Sándor 2005. szeptember A Java programozási nyelv Soós Sándor 1/20 Tartalomjegyzék
RészletesebbenWeb-technológia PHP-vel
Web-technológia PHP-vel A PHP programnyelv 2, futtatókörnyezet beálĺıtások Erős Bence February 26, 2013 Erős Bence () Web-technológia PHP-vel February 26, 2013 1 / 19 Szuperglobális változók $ GET : request
RészletesebbenProgramozási nyelvek Java
Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 9. előadás Interface - típust vezet be, de osztálypéldány nem készíthető belőle (statikus típust ad) - több osztály is
RészletesebbenOktatási segédlet 2014
Oktatási segédlet 2014 A kutatás a TÁMOP 4.2.4.A/2-11-1-2012- 0001 azonosító számú Nemzeti Kiválóság Program Hazai hallgatói, illetve kutatói személyi támogatást biztosító rendszer kidolgozása és működtetése
Részletesebben1.1. A forrásprogramok felépítése Nevek és kulcsszavak Alapvető típusok. C programozás 3
Darvay Zsolt Típusok és nevek a forráskódban Állandók és változók Hatókörök és az előfeldolgozó Bevitel és kivitel Kifejezések Utasítások Mutatók Függvények Struktúrák és típusok Állománykezelés C programozás
RészletesebbenProgramozás alapjai. 5. előadás
5. előadás Wagner György Általános Informatikai Tanszék Cserélve kiválasztásos rendezés (1) A minimum-maximum keresés elvére épül. Ismétlés: minimum keresés A halmazból egy tetszőleges elemet kinevezünk
Részletesebben1. Template (sablon) 1.1. Függvénysablon Függvénysablon példányosítás Osztálysablon
1. Template (sablon) 1.1. Függvénysablon Maximum függvény megvalósítása függvénynév túlterheléssel. i n l i n e f l o a t Max ( f l o a t a, f l o a t b ) { return a>b? a : b ; i n l i n e double Max (
RészletesebbenInformatika terméktervezőknek
Informatika terméktervezőknek C# alapok Névterület (namespace) using Osztály (class) és Obejtumok Metódus (function, procedure, method) main() static void string[] arg Szintaxis // /* */ \n \t Névadások
RészletesebbenBevezetés a C++ programozási nyelvbe
Bevezetés a C++ programozási nyelvbe Miskolci Egyetem Általános Informatikai Tanszék CPP0 / 1 Története A C++ programozási nyelv a C programozási nyelv objektum orientált kiterjesztése. Az ANSI-C nyelvet
RészletesebbenProgramozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar
Programozás I. 3. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Antal Gábor 1 Primitív típusok Típus neve Érték Alap érték Foglalt tár Intervallum byte Előjeles egész 0 8 bit
RészletesebbenProgramfejlesztési Modellek
Programfejlesztési Modellek Programfejlesztési fázisok: Követelmények leírása (megvalósíthatósági tanulmány, funkcionális specifikáció) Specifikáció elkészítése Tervezés (vázlatos és finom) Implementáció
RészletesebbenProgramozási nyelvek Java
statikus programszerkezet Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 2. előadás csomag könyvtárak könyvtárak forrásfájlok bájtkódok (.java) (.class) primitív osztály
Részletesebben2016, Funkcionális programozás
Funkcionális programozás 11. előadás Sapientia Egyetem, Műszaki és Humántudományok Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2016, tavaszi félév Miről volt szó? Haskell I/O műveletek, feladatok:
RészletesebbenSegédanyagok. Formális nyelvek a gyakorlatban. Szintaktikai helyesség. Fordítóprogramok. Formális nyelvek, 1. gyakorlat
Formális nyelvek a gyakorlatban Formális nyelvek, 1 gyakorlat Segédanyagok Célja: A programozási nyelvek szintaxisának leírására használatos eszközök, módszerek bemutatása Fogalmak: BNF, szabály, levezethető,
RészletesebbenA függvény kód szekvenciáját kapcsos zárójelek közt definiáljuk, a { } -ek közti részt a Bash héj kód blokknak (code block) nevezi.
Függvények 1.Függvények...1 1.1.A függvény deníció szintaxisa... 1..Függvények érték visszatérítése...3 1.3.Környezettel kapcsolatos kérdések...4 1.4.Lokális változók használata...4 1.5.Rekurzív hívások...5.kód
RészletesebbenInterfészek. PPT 2007/2008 tavasz.
Interfészek szenasi.sandor@nik.bmf.hu PPT 2007/2008 tavasz http://nik.bmf.hu/ppt 1 Témakörök Polimorfizmus áttekintése Interfészek Interfészek kiterjesztése 2 Már megismert fogalmak áttekintése Objektumorientált
RészletesebbenALAPFOGALMAK 1. A reláció az program programfüggvénye, ha. Azt mondjuk, hogy az feladat szigorúbb, mint az feladat, ha
ALAPFOGALMAK 1 Á l l a p o t t é r Legyen I egy véges halmaz és legyenek A i, i I tetszőleges véges vagy megszámlálható, nem üres halmazok Ekkor az A= A i halmazt állapottérnek, az A i halmazokat pedig
RészletesebbenBánsághi Anna 2014 Bánsághi Anna 1 of 33
IMPERATÍV PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 7. ELŐADÁS - ABSZTRAKT ADATTÍPUS 2014 Bánsághi Anna 1 of 33 TEMATIKA I. ALAPFOGALMAK, TUDOMÁNYTÖRTÉNET II. IMPERATÍV PROGRAMOZÁS Imperatív
RészletesebbenOBJEKTUM ORIENTÁLT PROGRAMOZÁS JAVA NYELVEN. vizsgatételek
OBJEKTUM ORIENTÁLT PROGRAMOZÁS JAVA NYELVEN vizsgatételek 1. Az objektumorientált programozás szemlélete, az objektum fogalma 2. Az objektumorientált programozás alapelvei 3. A Java nyelv története, alapvető
RészletesebbenA Feldspar fordító, illetve Feldspar programok tesztelése
A Feldspar fordító, illetve Feldspar programok tesztelése [KMOP-1.1.2-08/1-2008-0002 társfinanszírozó: ERFA] Leskó Dániel Eötvös Loránd Tudományegyetem Programozási Nyelvek és Fordítóprogramok Tanszék
RészletesebbenLogika es sz am ıt aselm elet I. r esz Logika 1/36
1/36 Logika és számításelmélet I. rész Logika 2/36 Elérhetőségek Tejfel Máté Déli épület, 2.606 matej@inf.elte.hu http://matej.web.elte.hu Tankönyv 3/36 Tartalom 4/36 Bevezető fogalmak Ítéletlogika Ítéletlogika
RészletesebbenC++ programozási nyelv
C++ programozási nyelv Gyakorlat - 13. hét Nyugat-Magyarországi Egyetem Faipari Mérnöki Kar Informatikai Intézet Soós Sándor 2004. december A C++ programozási nyelv Soós Sándor 1/10 Tartalomjegyzék Objektumok
Részletesebben1. Egyszerű (primitív) típusok. 2. Referencia típusok
II. A Java nyelv eszközei 1. Milyen eszközöket nyújt a Java a programozóknak Korábban már említettük, hogy a Java a C nyelvből alakult ki, ezért a C, C++ nyelvben járatos programozóknak nem fog nehézséget
RészletesebbenBevezetés a programozásba Előadás: Objektumszintű és osztályszintű elemek, hibakezelés
Bevezetés a programozásba 2 7. Előadás: Objektumszű és osztályszű elemek, hibakezelés ISMÉTLÉS Osztály class Particle { public: Particle( X, X, Y); virtual void mozog( ); ); virtual void rajzol( ) const;
RészletesebbenA fordítóprogramok szerkezete. Kódoptimalizálás. A kódoptimalizálás célja. A szintézis menete valójában. Kódoptimalizálási lépések osztályozása
A fordítóprogramok szerkezete Forrásprogram Forrás-kezelő (source handler) Kódoptimalizálás Fordítóprogramok előadás (A,C,T szakirány) Lexikális elemző (scanner) Szintaktikus elemző (parser) Szemantikus
RészletesebbenC programozási nyelv Pointerek, tömbök, pointer aritmetika
C programozási nyelv Pointerek, tömbök, pointer aritmetika Dr. Schuster György 2011. június 16. C programozási nyelv Pointerek, tömbök, pointer aritmetika 2011. június 16. 1 / 15 Pointerek (mutatók) Pointerek
Részletesebben1. Bevezetés A C++ nem objektumorientált újdonságai 3
Előszó xiii 1. Bevezetés 1 2. A C++ nem objektumorientált újdonságai 3 2.1. A C és a C++ nyelv 3 2.1.1. Függvényparaméterek és visszatérési érték 3 2.1.2. A main függvény 4 2.1.3. A bool típus 4 2.1.4.
RészletesebbenAlgoritmizálás + kódolás C++ nyelven és Pascalban
Algoritmizálás + kódolás nyelven és ban Motiváció A Programozási alapismeretek tárgyban az algoritmizáláshoz struktogramot, a kódoláshoz nyelvet használunk, a Közismereti informatikában (a közoktatásban
RészletesebbenKOMPUTER-ALGEBRA RENDSZEREK VERIFIKÁCIÓJA
KOMPUTER-ALGEBRA RENDSZEREK VERIFIKÁCIÓJA Szoftver Verifikáció és Validáció, 2015 Ősz Vaitkus Márton Tartalom Motiváció Maple MiniMaple MiniMaple típusellenőrzése MiniMaple formális specifikációja MiniMaple
RészletesebbenRekurzió. Dr. Iványi Péter
Rekurzió Dr. Iványi Péter 1 Függvényhívás void f3(int a3) { printf( %d,a3); } void f2(int a2) { f3(a2); a2 = (a2+1); } void f1() { int a1 = 1; int b1; b1 = f2(a1); } 2 Függvényhívás void f3(int a3) { printf(
RészletesebbenCekla. Készítette Doxygen Tue Sep :13:44
Cekla Készítette Doxygen 1.7.1 Tue Sep 20 2011 14:13:44 TARTALOMJEGYZÉK 1 Tartalomjegyzék 1. Cekla C++ könyvtár deklaratív C++-hoz 1 2. Modulmutató 1 2.1. Modulok............................................
RészletesebbenProgramozási nyelvek a közoktatásban alapfogalmak II. előadás
Programozási nyelvek a közoktatásban alapfogalmak II. előadás Szintaxis, szemantika BNF szintaxisgráf absztrakt értelmező axiomatikus (elő- és utófeltétel) Pap Gáborné. Szlávi Péter, Zsakó László: Programozási
RészletesebbenAritmetikai kifejezések lengyelformára hozása
Aritmetikai kifejezések lengyelformára hozása Készítették: Santák Csaba és Kovács Péter, 2005 ELTE IK programtervező matematikus szak Aritmetikai kifejezések kiértékelése - Gyakran felmerülő programozási
RészletesebbenA C programozási nyelv I. Bevezetés
A C programozási nyelv I. Bevezetés Miskolci Egyetem Általános Informatikai Tanszék A C programozási nyelv I. (bevezetés) CBEV1 / 1 A C nyelv története Dennis M. Ritchie AT&T Lab., 1972 rendszerprogramozás,
RészletesebbenAWK programozás, minták, vezérlési szerkezetek
10 AWK programozás, minták, vezérlési szerkezetek AWK adatvezérelt szkriptnyelv text processing, adat kiterjesztés, tagolt adatok automatizált soronkénti feldolgozása a forrásállományt soronként beolvassa
RészletesebbenAlgoritmizálás és adatmodellezés tanítása 1. előadás
Algoritmizálás és adatmodellezés tanítása 1. előadás Algoritmus-leíró eszközök Folyamatábra Irányított gráf, amely csomópontokból és őket összekötő élekből áll, egyetlen induló és befejező éle van, az
RészletesebbenKarakterkészlet. A kis- és nagybetűk nem különböznek, a sztringliterálok belsejét leszámítva!
A PL/SQL alapelemei Karakterkészlet Az angol ABC kis- és nagybetűi: a-z, A-Z Számjegyek: 0-9 Egyéb karakterek: ( ) + - * / < > =! ~ ^ ; :. ' @ %, " # $ & _ { }? [ ] Szóköz, tabulátor, kocsivissza A kis-
RészletesebbenMindent olyan egyszerűvé kell tenni, amennyire csak lehet, de nem egyszerűbbé.
HA 1 Mindent olyan egyszerűvé kell tenni, amennyire csak lehet, de nem egyszerűbbé. (Albert Einstein) HA 2 Halmazok HA 3 Megjegyzések A halmaz, az elem és az eleme fogalmakat nem definiáljuk, hanem alapfogalmaknak
RészletesebbenAlkalmazott modul: Programozás 4. előadás. Procedurális programozás: iteratív és rekurzív alprogramok. Alprogramok. Alprogramok.
Eötvös Loránd Tudományegyetem Informatikai Kar Alkalmazott modul: Programozás 4. előadás Procedurális programozás: iteratív és rekurzív alprogramok Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto
RészletesebbenTömbök kezelése. Példa: Vonalkód ellenőrzőjegyének kiszámítása
Tömbök kezelése Példa: Vonalkód ellenőrzőjegyének kiszámítása A számokkal jellemzett adatok, pl. személyi szám, adószám, taj-szám, vonalkód, bankszámlaszám esetében az elírásból származó hibát ún. ellenőrző
RészletesebbenProgramozási nyelvek Java
Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 8. előadás Öröklődés - megnyitunk egy osztályt egy másik előtt zárt egységeket szeretünk készíteni (láthatósági kérdés:
RészletesebbenJava programozási nyelv
Java programozási nyelv 2. rész Vezérlő szerkezetek Nyugat-Magyarországi Egyetem Faipari Mérnöki Kar Informatikai Intézet Soós Sándor 2005. szeptember A Java programozási nyelv Soós Sándor 1/23 Tartalomjegyzék
RészletesebbenAmortizációs költségelemzés
Amortizációs költségelemzés Amennyiben műveleteknek egy M 1,...,M m sorozatának a futási idejét akarjuk meghatározni, akkor egy lehetőség, hogy külön-külön minden egyes művelet futási idejét kifejezzük
RészletesebbenA C programozási nyelv I. Bevezetés
A C programozási nyelv I. Bevezetés Miskolci Egyetem Általános Informatikai Tanszék A C programozási nyelv I. (bevezetés) CBEV1 / 1 A C nyelv története Dennis M. Ritchie AT&T Lab., 1972 rendszerprogramozás,
RészletesebbenProgramozás II. 2. gyakorlat Áttérés C-ről C++-ra
Programozás II. 2. gyakorlat Áttérés C-ről C++-ra Tartalom Új kommentelési lehetőség Változók deklarációjának helye Alapértelmezett függvényparaméterek Névterek I/O műveletek egyszerűsödése Logikai adattípus,
RészletesebbenHalmazelmélet. 1. előadás. Farkas István. DE ATC Gazdaságelemzési és Statisztikai Tanszék. Halmazelmélet p. 1/1
Halmazelmélet 1. előadás Farkas István DE ATC Gazdaságelemzési és Statisztikai Tanszék Halmazelmélet p. 1/1 A halmaz fogalma, jelölések A halmaz fogalmát a matematikában nem definiáljuk, tulajdonságaival
RészletesebbenOOP: Java 8.Gy: Abstract osztályok, interfészek
OOP: Java 8.Gy: Abstract osztályok, interfészek 26/1 B ITv: MAN 2019.04.03 Abszrakt metódus és absztrakt osztály. Gyakran előfordul a tervezés során, hogy egy osztály szintjén tudjuk, hogy valamilyen metódus
RészletesebbenImperatív és procedurális programozás a Javában
Imperatív és procedurális programozás a Javában Kozsik Tamás kto@elte.hu http://kto.web.elte.hu/ Eötvös Loránd Tudományegyetem Programozási Nyelvek és Fordítóprogramok Tanszék 2008. Kozsik Tamás (ELTE)
RészletesebbenKOVÁCS BÉLA, MATEMATIKA I.
KOVÁCS BÉLA, MATEmATIkA I. 4 IV. FÜGGVÉNYEk 1. LEkÉPEZÉSEk, függvények Definíció Legyen és két halmaz. Egy függvény -ből -ba egy olyan szabály, amely minden elemhez pontosan egy elemet rendel hozzá. Az
RészletesebbenProgramozás BMEKOKAA146. Dr. Bécsi Tamás 2. előadás
Programozás BMEKOKAA146 Dr. Bécsi Tamás 2. előadás Szintaktikai alapok Alapvető típusok, ismétlés C# típus.net típus Méret (byte) Leírás byte System.Byte 1Előjel nélküli 8 bites egész szám (0..255) char
RészletesebbenMindent olyan egyszerűvé kell tenni, amennyire csak lehet, de nem egyszerűbbé. (Albert Einstein) Halmazok 1
Halmazok 1 Mindent olyan egyszerűvé kell tenni, amennyire csak lehet, de nem egyszerűbbé. (Albert Einstein) Halmazok 2 A fejezet legfontosabb elemei Halmaz megadási módjai Halmazok közti műveletek (metszet,
RészletesebbenPénzügyi algoritmusok
Pénzügyi algoritmusok A C++ programozás alapjai Tömbök (3. rész) Konstansok Kivételkezelés Tömbök 3. Többdimenziós tömbök Többdimenziós tömbök int a; Többdimenziós tömbök int a[5]; Többdimenziós tömbök
RészletesebbenAWK programozás Bevezetés
09 AWK programozás Bevezetés AWK adatvezérelt szkriptnyelv text processing, adat kiterjesztés, tagolt adatok automatizált soronkénti feldolgozása a forrásállományt soronként beolvassa és feldolgozhatóvá
RészletesebbenOperációs rendszerek. 9. gyakorlat. BASH recap, reguláris kifejezések UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED
UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED BASH recap, reguláris kifejezések Operációs rendszerek 9. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Csuvik Viktor
RészletesebbenBevezetés, a C++ osztályok. Pere László
Programozás módszertan II. p. Programozás módszertan II. Bevezetés, a C++ osztályok Pere László (pipas@linux.pte.hu) PÉCSI TUDOMÁNYEGYETEM TERMÉSZETTUDOMÁNYI KAR INFORMATIKA ÉS ÁLTALÁNOS TECHNIKA TANSZÉK
RészletesebbenAdatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája
Adatszerkezetek Összetett adattípus Meghatározói: A felvehető értékek halmaza Az értékhalmaz struktúrája Az ábrázolás módja Műveletei Adatszerkezet fogalma Direkt szorzat Minden eleme a T i halmazokból
RészletesebbenBevezetés a programozásba
Bevezetés a programozásba 1. Előadás Bevezetés, kifejezések http://digitus.itk.ppke.hu/~flugi/ Egyre precízebb A programozás természete Hozzál krumplit! Hozzál egy kiló krumplit! Hozzál egy kiló krumplit
RészletesebbenFormális szemantika. Kifejezések szemantikája. Horpácsi Dániel ELTE Informatikai Kar
Formális szemantika Kifejezések szemantikája Horpácsi Dániel ELTE Informatikai Kar 2016-2017-2 Az előadás témája Egyszerű kifejezések formális szemantikája Az első lépés a programozási nyelvek szemantikájának
RészletesebbenBevezetés a Programozásba II 2. előadás. Adattípusok megvalósítása egységbe zárással. Adattípusok megvalósítása egységbe zárással
Pázmány Péter Katolikus Egyetem Információs Technológiai és Bionikai Kar Bevezetés a Programozásba II 2. előadás Adattípusok megvalósítása egységbe zárással 2014.02.17. Giachetta Roberto groberto@inf.elte.hu
RészletesebbenFunkcionális programozás
Funkcionális programozás Horváth Zoltán E-mail: hz@inf.elte.hu Eötvös Lóránd Tudományegyetem, Budapest Programozási Nyelvek és Fordítóprogramok Tanszék Ajánlott irodalom Plasmeijer et al.: Programming
RészletesebbenProgramozás II. 3. gyakorlat Objektum Orientáltság C++-ban
Programozás II. 3. gyakorlat Objektum Orientáltság C++-ban Tartalom OOP ismétlés Osztályok létrehozása Adattagok láthatóságai, elnevezési ajánlások Konstruktor, destruktor this pointer Statikus és dinamikus
RészletesebbenOperációs rendszerek. 11. gyakorlat. AWK - szintaxis, vezérlési szerkezetek UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED
UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED AWK - szintaxis, vezérlési szerkezetek Operációs rendszerek 11. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Csuvik
RészletesebbenJAVA PROGRAMOZÁS 2.ELŐADÁS
Dr. Pál László, Sapientia EMTE, Csíkszereda JAVA PROGRAMOZÁS 2.ELŐADÁS 2014-2015 tavasz Tömbök, osztályok, objektumok, konstruktorok Tömbök 2 Referencia típusú változó Elemtípus Primitív Referencia: osztály,
RészletesebbenA félév során előkerülő témakörök
A félév során előkerülő témakörök rekurzív algoritmusok rendező algoritmusok alapvető adattípusok, adatszerkezetek, és kapcsolódó algoritmusok dinamikus programozás mohó algoritmusok gráf algoritmusok
Részletesebben