Scene.hu

Végre, végre, itt a negyedik rész, csak itt, csak most, csak önöknek, 150%-al több kódrészlettel!

Komolyabbra fordítva a szót, többen konkrét példákat kértek rajtam számon; úgyhogy gondoltam is, hogy akkor a mai részben ilyenek lesznek (bár szerintem az eddigiek is azok voltak). De aztán meggondoltam magam (ördögi kacaj), és főleg az IO monádra fogok koncentrálni (még ördögibb kacaj :)… Mindenesetre a copy/paste-el csak óvatosan – a szerző is megjárta már ezzel -, ugyanis a weboldalról másolt kódrészletek, bár első ránézésre jónak tűnhetnek, a sortörés karaktereket nem feltétlenül a rendszer natív formájában tartalmazzák, ami a compilert könnyen meggátolhatja a rendeltetésszerű működésben… (nyilván ez rendszer- és böngészőfüggő).

Jó hír viszont, hogy múlt szombaton kijött a GHC compiler legújabb, 6.8.1-es változata (a számozásból naívan levonhtató következtetésekkel ellentétben ez egy major release, az utolsó hasonló a 6.6.1 volt, áprilisban, előtte pedig a 6.6, tavaly októberben).

Az előző részek itt találhatóak: első, második, harmadik.

Vágjunk akkor bele!

Így kezdődik egy Haskell program, mely első sorban megmondjuk az adott module nevét (ami mindig nagybetűvel kezdődik, hasonlóan a típusokhoz, adatkonstruktorokhoz, és típusosztályokhoz, és ellentétben a függvényekkel, argumentumokkal és típusváltozókkal, melyek kisbetűvel kezdődnek). Amíg ilyen kis egyszerű egyfile-os programokról van szó, ez nem igazán számít, egyébként viszont elvárják az embertől, hogy a filenév és a module neve stimmeljen, library-k esetén legalábbis; illetve ha futtatható programot szeretnénk, akkor a module neve legyen Main, és legyen egy main :: IO () típusú “függvény” (pont mint C-ben a void main() { … }). Bery egy hónappal korábbi kérdésére válaszolva :), a module-nak a file végén van vége, tehát 1 file = 1 module.

Ez után beimportálhatjuk a namespace-be a library-k közül azokat amiket használni szeretnénk (a linkre kattintva a GHC standard library-k dokumentációját találjuk). Van egy alapértelmezett készlet, az ún. Prelude, amit mindig beimportál nekünk a compiler, kivéve ha szólunk neki hogy ne tegye. Egyébként a többi importálást is lehet finomhangolni, expliciten megmondva hogy melyik függvényt szeretnénk illetve melyiket nem.

És már írhatjuk is a kódot! Innentől a dolgok sorrendje nem számít. Kezdjük mondjuk egy egyszerű, sőt, egyenesen naív, ámde annál rövidebb quicksort implementációval:

A legtöbb Haskell compilernek/interpreternek van REPL, azaz Read-Eval-Print Loop funkcionalitása, amiben interaktívan ki is tudjuk próbálni a kódot. A GHCi nevűt használva ez valahogy így néz ki:

Látszólag működik…

Kis magyarázat a kódhoz: a partition nevű függvény, ami a Data.List library része, típusa pedig (a -> Bool) -> [a] -> ([a],[a]), szóval ez azt csinálja, hogy az első paraméterként kapott függvényt használva szétbontja a második paraméterként kapott listát két részre, és ezeket egy párként adja vissza. Vegyük észre, hogy bár a “listák párja” az egy darab objektum, de a pattern matching segítségével ingyen megkapjuk azt a fícsört, mintha több visszatérési értéke is lehetne egy függvénynek (Charlie, figyelsz? :) A (<x) pedig az a függvény, amit így is lehetne definiálni: (<x) y = y < x.

Hogy egy egészen igazi programot is lássunk, kimenettel, bemenettel és rózsaszín mignonnal, álljon itt egy program(ocska), mely megszámolja a standard input-on érkező szövegben a szavakat (lásd még a unix wc parancsot, mint “word count”).

(megjegyzem, elég sok más unix parancsot is lehet egysoros Haskell programokként implementálni :). Az interact függvény egyetlen paramétere egy (String -> String) típusú függvény, kimenete pedig egy IO action:

mely azt csinálja, hogy a standard inputra érkező adatra ráengedi ezt a függvényt, a végeredményt pedig kitolja a standard outputra. A $ karakter a függvény-applikáció operátor: f $ x = f x. Ennek látszólag nem sok értelme van, azonban nagyon alacsony a precedenciája, így sokszor meg lehet szabadulni zárójelhalmazoktól a segítségével. Tehát írhattam volna azt is, hogy interact (show.length.words), a kettő teljesen ekvivalens. A . operátor pedig a függvény-kompozíció operátor: (f.g) x = f (g x); típusa (.) :: (b -> c) -> (a -> b) -> a -> c. Matematikában ezt kis karikával szokták jelölni, de olyan nincs az ASCII karakterkészletben (bár Haskellben elvileg használhatunk Unicode operátorokat is, a standard library-ben nincsenek ilyenek jelenleg). (Érdekesség, hogy első ránézésre teljesen önellentmondó módon, ezt a programozási stílust, amikor függvény-kompozíciókkal operálnak explicit paraméterek helyett, “point-free style”-nak hívják :). A feloldás ott van, hogy a “point” itt nem a . operátorra utal, hanem… valami egész másra, ami a matematika mély bugyraiban található. Itt kicsit elbizonytalanodtam, mert a hirtelen talált egyetlen referencia szerint egész másra utal (bónuszként az viszont a matematika még mélyebb bugyraiban leledzik), mint azt én gondoltam eddig :). Végül, a words szavak listájára bont egy string-et, a length megmondja egy lista hosszát, a show pedig stringgé alakít egy objektumot, jelen esetben egy számot.

Azt hiszem, pár szót kellene szólnom erről a misztikus IO típuskonstruktorról. A korábbiakkal ellentétben ennek nincs definíciója, hanem a fordítóba van beépítve; ebből a szempontból speciális, ámde minden más szempontból úgy viselkedik, mint bármely más típuskonstruktor. Az IO a típus egy olyan, esetleges side-effectekkel bíró actiont reprezentál, mely végeredményként egy a típusú értéket ad vissza. Pedagógiailag képzelhetjük azt, hogy ez a definíció:

ahol egy misztikus World típus reprezentálja a világ állapotát, amitől az IO action függhet, illetve azt megváltoztathatja. Emlékezzünk rá, hogy a Haskell egy pure nyelv: a függvényeknek nincs megengedve, hogy megváltoztassák a világ állapotát, sőt, az sem, hogy az befolyásolja az eredményüket! Talán segít a megértésben a következő két sor:

Itt a () az úgynevezett Unit típust jelöli: ennek egyetlen értéke van, amit szintén ()-al jelölnek (ez sajnos nem teljesen igaz, mert a nyelv lazy; de a mi szempontunkból megfelelő definíció). Tehát az IO () az egy olyan IO action, ami nem ad vissza semmit (legalábbis semmi érdekeset).

A fenti pedagógiai definícióval élve, az IO is egy monád, mégpedig a következő módon:

Aki ezt érti, az lényegében érti az IO-t a Haskellben :). Sajnos ez most kicsit komplikált lett, de hát such is life, mondaná az angol… A lényeg, hogy a World -> (World,a) típusú függvényeket értelemszerűen fűzzük össze (emlékezzünk, hogy >>= operátor típusa Monad m => m a -> (a -> m b) -> m b). Azt azért még elmondom, hogy a \ karakter segítségével anonim függvényeket vezethetünk be, például

Ez gyakran nagyon hasznos és/vagy kényelmes. Egyébként azért pont backslash, mert ezt klasszikusan a lambda görög betűvel, mint λ, jelölik a logikusok; viszont olyan nincs az ASCII-ban, és még ez “hasonlít” a legjobban.

Na a lényeg talán kicsit elveszett menetközben: Az IO actionök pont ugyanolyan objektumok, mint bármi más a nyelvben, tehát átadhatjuk őket paraméterként, listákat építhetünk belőlük, vagy akár bináris fákat, vagy bármi mást!

Például, ha van egy listánk a -> IO a típusú függvényekből (amit úgy is képzelhetünk, hogy egy IO action, melynek bemenete és kimenete is egy a típusú) akkor szépen sorban összefűzhetjük őket:

Ráadásul ez automatikusan működni fog minden monádra, nemcsak az IO-ra. Ha például a múltkori cikk végén levő Maybe-s példában olyan részfeladatokat akartunk volna összefűzni, amelyek egy fix tipusú adatot dolgoznak fel, mondjuk stringeket, akkor ezzel a friss és ropogós függvénnyel is tehettük volna.

Ehhez hasonló módon igen egyszerű új control flow primitívek létrehozása. Triviális példák:

És egy nemtriviális példa (amely az előzőekre is épít):

Ez azt csinálja, hogy egy IO actionből egy timeout-tal rendelkező IO actiont csinál: ha adott időn belül lefut a cucc, akkor visszakapjuk (Just) a választ, ha nem, akkor abort, és Nothing-ot kapunk visssza. (Egy fejletteb verziója ennek a szolgáltatásnak egyébként belekerült a standard library-be is a bevezetőben említett új GHC-ban). Ha peldául van egy hipotetikus getDataFromTheNet :: IO Stuff actionünk, akkor így (is) használhatjuk a fenti kódot:

Ebben a timeout-os kódrészletben megint sok újdonság bukkan fel; legérdekesebb talán az MVar. Ezek szinkronizáló változók, többek közt párhuzamosan futó threadek közti kommunikációra lehet őket használni. Működésük nagyon egyszerű: vagy üresek, vagy valamilyen érték van bennük. Egy thread kiveheti egy ilyenből az értékét (takeMVar), és akkor üres lesz; de ha eleve üres volt, akkor a thread várakozik addig, amíg teli nem lesz. Hasonlóan, egy üres MVar-ba bele lehet tenni valamilyen értéket (putMVar), de ha nem volt üres, akkor várunk. A runtime garantálja nekünk, hogy ezek atomi műveletek, nem történhet meg hogy az egyik thread pont akkor kezd el írni, amikor a másik épp valami olvasás közepén van. További érdekesség, de roppant hasznos, hogy a compiler/runtime néha ki tudja analizálni a deadlockokat, és ha ilyenbe kerülne a program, akkor inkább kilép egy hibaüzenettel, ahelyett hogy csak állna ott az idők végezetéig. Persze ennél bonyolultabb dolgokat is lehet csinálni, ízelítőül néhány alapvető függvény (a típusokból jól látszik, hogy mivel változókról van szó, az egész biznisz az IO monádban zajlik):

Egyébként rengeteg monád van még a Maybe-n és az IO-n kívül is, kezdve magukkal a listákkal (házi feladat kitalálni, hogy hogyan) az igen hasznos State monádokig (melyekkel titokban változókat használó, de összességében mégis pure függvényeket írhatunk, mint pl. egy imperatív quicksort verzió, destruktív update-ekkel).

És a konklúzió? A Haskell tulajdonképpen imperatív nyelvnek sem utolsó… :)