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 jellemzői: megjegyzések használata, mintaillesztés, feltételek megadása, szigorú, statikus típusosság, rekurzió, margó szabály halmazkifejezések lambda kifejezések magasabb rendű függvények magasabb rendű függvények részleges paraméterezése feltételes kifejezések
Miről lesz szó? GHC parancsok fenntartott szavak könyvtármodul importálása A Haskell további jellemzői: feltételek egymásba ágyazása a let...in, where kifejezések a case...of kifejezés függvénykompozícíó függvénykiértékelés a $ szimbólummal a $ és a. szimbólumok a tuple típus, könyvtárfüggvények a lista típus, könyvtárfüggvények operátorok, függvények listákon
GHC parancsok lehet rövidített formában is használni őket, a parancs kezdőbetűjével: :load fnev.hs az fnev.hs nevű állomány betöltése, :reload fnev.hs az fnev.hs nevű állomány újrabetöltése, :type kif a kif kifejezése típusának a lekérdezése, :t kif :? az összes GHC parancs lekérdezése, :quit kilépés a GHC-ből, :set +t a kiértékelés után a kifejezés típusa is megjelenik :unset +t az előző beálĺıtás visszavonása :set +s a kiértékelés után megjelenik az eltelt idő és a lefoglalt bájtok száma :!cd az aktuális könyvtár (directory) állapot lekérdezése :cd C:\Diak könyvtár (directory) változtatás...
Fenntartott szavak case class data default deriving do else if import in infix infixl infixr instance let module newtype of then type where
Könyvtármodul importálása import Data.Char > isdigit 3 > isdigit w True False > isalpha a > isalpha? True False my_isdigit :: Char -> Bool my_isdigit x = x >= 0 && x <= 9 > my_isdigit 3 True > import Data.List > tails "hello" ["hello","ello","llo","lo","o",""] > import Data.Complex > sum[3 :+ (-2.6), 11 :+ 3.4, 1 :+ (-2.41), (-8) :+ 4.11] 7.0 :+ 2.5
Feltételek egymásba ágyazása 1. feladat Vizsgáljunk egy számot: pozitív-e, osztható-e hattal, stb.? fugvp :: Int -> [Char] fugvp n n > 0, mod n 2 == 0, mod n 3 == 0 = "pozitiv, oszthato 6-al" n > 0, mod n 2 == 0, mod n 3 /= 0 = "pozitiv, nem oszthato 6-al" n > 0, mod n 2 == 1 = "pozitiv paratlan" n < 0, mod n 2 == 0 = "negativ paros" otherwise = "negativ paratlan" > fugvp 10 > fugvp 11 > fugvp (-10)
A let...in kifejezés 2. feladat Határozzuk meg egy másodfokú egyenlet valós gyökeit. gyok_ :: (Fractional a, Floating a, Ord a) => a -> a -> a -> (a, a) gyok_ a b c = let x1 = (-b + sqrt delta) / n x2 = (-b - sqrt delta) / n delta = b * b - 4 * a * c n = 2 * a in if delta < 0 then error "Komplex gyokok" else (x1, x2)
A case...of kifejezés 3. feladat Határozzuk meg egy számjegy 16-os számrendszerbeli alakját, ahol a kíıratást az A, B, C, D, E, F szimbólumok segítségével végezzük. szimb :: Int -> Char szimb c c >= 0 && c < 16 = case c of 10 -> A 11 -> B 12 -> C 13 -> D 14 -> E 15 -> F _ -> chr (c + 48) otherwise = error "rossz bemenet" > szimb 15 > szimb 19 F *** Exception: rossz bemenet
Függvénykompozíció A matematikából ismert művelet megfelelője. 4. feladat Határozzuk meg a paraméterként megadott számok közül a páratlan számokat. paratlanlista :: (Integral a) => [a] -> [a] paratlanlista ls = filter (not. even) ls > paratlanlista [1..20] [1,3,5,7,9,11,13,15,17,19] Nem kell explicit módon megadni a paramétert: paratlanlista1 :: (Integral a) => [a] -> [a] paratlanlista1 = filter (not. even) > paratlanlista1 [1..20] [1,3,5,7,9,11,13,15,17,19]
Függvénykompozíció Nem kell explicit módon megadni a paramétert a korábbi duplaz függvény esetében sem: duplaz2 :: (Num a) => a -> a duplaz2 = my_inc. my_inc > duplaz2 12 14
Függvénykompozíció 5. feladat Vágjuk le a paraméterként megadott lista, karakterlánc első és utolsó karakterét. Alkalmazzuk az init, tail könyvtárfüggvényeket. > init [1..10] [1,2,3,4,5,6,7,8,9] > tail [1..10] [2,3,4,5,6,7,8,9,10] levag :: [a] -> [a] levag = init.tail > levag "gezakekazeg" "ezakekaze"
Függvénykiértékelés a $ szimbólummal A függvény kiértékelési sorrendjét tudjuk megváltoztatni. Fölöslegessé válik a zárójelezés: hamarabb kiértékelődik a $ két oldalán levő kifejezés, jobbról asszociatív (azaz előbb a jobboldalon levő kifejezés értékelődik ki). A $ oparátornak, az operátorok között legkisebb a prioritása. Meghatározza 2, majd hozzáadja a 3-t, majd az 5-t: > sqrt 2 + 3 + 5 9.414213562373096 Összeadja a számokat és azután határozza meg 10 értékét: > sqrt (2 + 3 + 5) 3.1622776601683795 Összeadja a számokat és azután határozza meg 10 értékét: > sqrt $ 2 + 3 + 5 3.1622776601683795
Függvénykiértékelés a $ szimbólummal Előbb alkalmazza az abs függvényt: > sqrt $ abs (-16) 4.0 Összeadja a számokat, alkalmazza az abs függvényt, majd meghatározza a négyzetgyököt: > sqrt $ abs $ (-16) + 9 2.6457513110645907 Alkalmazza az abs függvényt, hozzáadja a 9-et, majd meghatározza a négyzetgyököt: > sqrt $ abs (-16) + 9 5.0
A $ és a. szimbólumok A. szimbólummal elsősorban az függvényhívások össze-láncolását (kompozicíóját) lehet megvalósítani, a lényeg nem a kevesebb zárójelhasználat, bár az eredmény az, hogy kevesebb zárójelt kell használni. Előbb alkalmazza az abs függvényt: > (sqrt. abs) (-16) 4.0 Ugyanazt érem el, mint az előbbi, de kevesebb zárójellel: > sqrt. abs $ -16 4.0
A $ és a. szimbólumok Előbb alkalmazza a head függvényt, majd a toupper függvényt és utána a : konstruktort, azaz épít egy új listát aminek az első eleme S : > import Data.Char > let fugvnb x = (toupper. head) x : tail x > fugvnb "sapientia" "Sapientia" > let fugvkb x = (tolower. head $ x) : tail x > fugvkb "SAPIENTIA" "sapientia"
A $ és a. szimbólumok A words a paraméterként megadott stringet szavakra bontja: > let list = words "sapientia hungarian university marosvasarhely" ["sapientia","hungarian","university","marosvasarhely"] > map fugvnb list ["Sapientia","Hungarian","University","Marosvasarhely"]... és a fenti példa más formái, lambda kifejezéssel: > ( map ( \ x -> ((toupper.head) x : tail x) ). words) "sapientia hungarian university marosvasarhely" > map (\ x -> ((toupper. head) x : tail x) ) (words "sapientia hungarian university marosvasarhely") > map (\ x -> ((toupper.head) x : tail x) ) $ words "sapientia hungarian university marosvasarhely"
A $ és a. szimbólumok Mit csinálnak az alábbi függvényhívások, ahol az atlag a számok átlagát meghatározó függvény? atlag :: (Floating a) => [a] -> a atlag ls = (sum ls) / fromintegral (length ls) > (atlag. filter (> 4.5)) [6.5, 7.4, 8.9, 9.5, 3.5, 6.3, 4.2] > atlag $ filter (> 4.5) [6.5, 7.4, 8.9, 9.5, 3.5, 6.3, 4.2] > (take 4. reverse. filter odd ) [1..20] > take 4. reverse. filter odd $ [1..20] > take 4 ( reverse ( filter odd [1..20])) > take 4 $ reverse $ filter odd $ [1..20]
A rendezett n-es (tuple) típus különböző típusú elemek halmaza, ahol, az elemek száma rögzített. Jelölésére a kerek zárójelt használjuk: (). > let my_tuple = ("Marika", 3, 8.75) > let (nev, evf, jegy) = my_tuple > print nev > "Marika" > print evf > 3 > print jegy > 8.75 egy 2 elemű tuple típuson alkalmazhatóak az fst és snd könyvtárfüggvények: > let my_tuple1 = ("Marika", 8.75) > fst my_tuple1 > "Marika" > snd my_tuple1 > 8.75
A tuple típus 6. feladat Határozzuk meg egy másodfokú egyenlet gyökeit. Az eredmény tuple típusú érték legyen. gyok :: Double -> Double -> Double -> (String, Double, Double) gyok a b c = if delta < 0 then error "Komplex gyokok" else if delta == 0 then ("egyforma gyokok: ", x1, x1) else ("ket gyok: ", x1, x2) where x1 = (-b + sqrt delta) / nev x2 = (-b - sqrt delta) / nev delta = b * b - 4 * a * c nev = 2 * a > gyok 1 3 2 ("ket gyok",-1.0,-2.0) > gyok 1 4 4 ("egyforma gyokok, ",-2.0,-2.0)
A tuple típus 7. feladat Definiáljunk egy Pont típusú értéket és írjunk három függvényt: definiáljuk a kezdőpontot, mozgassuk el a pontot, határozzuk meg két pont között a távolságot. type Szin = String type Pont = (Double, Double, Szin) kezdop :: Szin -> Pont kezdop szin = (0, 0, szin) > p1 = kezdop "fekete" > p2 = mozgat p1 10 15 > tavolsag p1 p2 18.027756377319946 mozgat :: Pont -> Double -> Double -> Pont mozgat (x, y, szin) xtav ytav = (x + xtav, y + ytav, szin) tavolsag :: Pont -> Pont -> Double tavolsag (x1, y1, szin1) (x2, y2, szin2) = sqrt (dx * dx + dy * dy) where dx = x2 - x1 dy = y2 - y1
A lista típus ugyanolyan típusú elemek sorozata, ahol az elemek száma változó. Jelölésére a szögletes zárójelt használjuk: [], sorszámozásuk nullától kezdődik. [] - egy üres listát mintáz, [x] - egy egyelemű listát mintáz, [x, y] - egy kételemű listát mintáz, (k : ve) - egy olyan listát mintáz, melynek első eleme k, ve pedig a lista vége, ahol k elem, ve lista típusú, Függvények listákon, lista elemeinek összege (sum), lista hossza (length), lista elemeinek megfordítása (reverse), stb: > sum [3, 2, 10, 7, 5] 27 > length [3, 2, 10, 7, 5] 5 > reverse [3, 2, 10, 7, 5] [5,7,10,2,3]
Operátorok listákon (:) :: a -> [a] -> [a] hozzáad egy új elemet a listához, amelyet a lista elejére tesz, a típusdefiníció általános lista feldolgozását teszi lehetővé, hozzárendeli a lista első elemét egy azonosítóhoz, a lista többi elemét, pedig egy másik nevű azonosítóhoz rendeli hozzá > ls1 = [1,2,3,4] > ls1_1 = 0: ls1 > print t1_1 [0, 1, 2, 3, 4] > ls2 = "apientia" > ls2_1 = S : ls2 > print ls2_1 "Sapientia" > k: ve = "Hello Vilag" > print k H > print ve "ello Vilag" > ls3 = [[1,2,3,4], [1,2,3], [1,2]] > ls3_1 = [1..5]: ls3 > print ls3_1 [[1,2,3,4,5], [1,2,3,4], [1,2,3], [1,2]]
Operátorok listákon > ls4 = [0,5..40] > print ls4 [0, 5, 10, 15, 20, 25, 30, 35, 40] > ls6 x = [2^x, length (show (2 ^ x))] > print ls6 10 [1024,4] > ls5 = [-3, -6.. -20] > print ls5 [-3, -6, -9, -12, -15, -18] > ls6_1 x = 3^x: length(show (3^x)): (ls6 x) > print ls6_1 10 [59049, 5, 1024, 4] > ls7 = [ a.. z ] > ls8 = [ A.. Z ] ++ ls7 > print ls8 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" > ls8!! 2 C
Függvények listákon head :: [a] -> a visszatéríti egy lista első elemét, nem alkalmazható üres listára, a típusdefiníció általános lista feldolgozását teszi lehetővé. my_head :: [a] -> a my_head [] = error "ures lista" my_head (k: ve) = k > my_head [1..10] 1 > my_head ["alma", "korte", "barack", "szilva"] "alma" > head [1..10] -- a konyvtarfuggveny 1
Függvények listákon tail :: [a] -> [a] egy listát térít vissza, amelyben nem szerepel az eredeti lista első eleme, nem alkalmazható üres listákra. my_tail :: [a] -> [a] my_tail [] = error "ures lista" my_tail (k: ve) = ve > my_tail [1..10] [2,3,4,5,6,7,8,9,10] > my_tail ["alma", "korte", "barack", "szilva"] ["korte", "barack", "szilva"] > tail [1..10] -- a konyvtarfuggveny [2,3,4,5,6,7,8,9,10]
Függvények listákon init :: [a] -> [a] egy listát térít vissza, amelyben nem szerepel az eredeti lista utolsó eleme, nem alkalmazható üres listákra. my_init :: [a] -> [a] my_init [] = error "ures lista" my_init [k] = [] my_init (k: ve) = (k: my_init ve) > my_init [1..10] [1,2,3,4,5,6,7,8,9] > init [1..10] -- a konyvtarfuggveny [1,2,3,4,5,6,7,8,9]
Függvények listákon last :: [a] -> a meghatározza egy lista utolsó elemét. my_last :: [a] -> a my_last [] = error "ures lista" my_last [k] = k my_last (k: ve) = my_last ve > my_last [1..10] 10 my_last "hello" o
Függvények listákon sum :: Num a => [a] -> a összeadja a lista elemeit. my_sum1 :: Num a => [a] -> a my_sum1 [] = 0 my_sum1 (k: ve) = k + my_sum1 ve my_sum2 :: Num a => [a] -> a my_sum2 [] = 0 my_sum2 ls = head ls + my_sum2 (tail ls) > my_sum1 [1..10] 55 > my_sum2 [1..10] 55 > sum [1..10] -- a konyvtarfuggveny 55
Függvények listákon összeadja a lista elemeit, harmadik verzió: my_sum3 :: Num a => [a] -> a my_sum3 ls = my_ssum3 ls 0 where my_ssum3 [] res = res my_ssum3 (k: ve) res = my_ssum3 ve (k + res) > my_sum3 [1..10] 55 > my_sum3 [9.8, 3.55, 4.9] 18.25 Komplex számok összeadása: > import Data.Complex > my_sum3 [3 :+ (-2.3), 3 :+ 2.1, 8.54 :+ 1.3] 14.54 :+ 1.1000000000000003