Mintaillesztés

Mintaillesztés: Prelude.not

Logikai tagadás:

not :: Bool -> Bool
not True  = False
not False = True

Egy függvényt több alternatívával (vagy szabállyal) is definiálhatunk. A függvényalternatíváknak egymás mellett kell elhelyezkedni a modulban.

A függvényparaméterek helyén minták vannak. A minta fogalmával a következő diákon ismerkedünk meg.

A függvényalternatívákat a kiértékelés során fentről lefelé próbáljuk végig.

Minták fajtái

Minta lehet:


A joker és a változó minden kifejezésre illeszkedik.

Prelude.&&

True  && True  = True
True  && False = False
False && True  = False
False && False = False

Logikai ÉS egyszerűbben:

Logikai ÉS másként:

Feladat: (Prelude.||) [*]

Definiáljuk újra a (||) operátort!

(||) :: Bool -> Bool -> Bool

Test>
True :: Bool
Test>
True :: Bool

Itt is el kell rejteni a (||) eredeti definícióját:

A ... helyén további elrejtendő definíciók lehetnek.

Feladat: Kizáró VAGY

Definiáljuk a kizáró VAGY függvényt!

xor :: Bool -> Bool -> Bool

Test>
False :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
False :: Bool

Minták párokra: Prelude.fst

Párokra illeszthető minta: (x, y).

Példák:

fst (a, b) = a
snd (a, b) = b

Használat:

Test>
2 :: Integer

Feladat: Elemcsere [*]

Cseréljük meg egy pár két elemét!

swap :: (a, b) -> (b, a)

Test>
("hi", 3) :: ([Char], Integer)

Feladat: Tükrözés az x tengelyre

Tükrözzünk egy pontot az x tengelyre!

mirrorX :: Num a => (a, a) -> (a, a)

Test>
(3, -4) :: (Integer, Integer)

Feladat: Origó középpontú nagyítás

scale' t legyen origó középpontú t-vel történő nagyítás!

scale' :: Num a => a -> (a, a) -> (a, a)

Test>
(15, 20) :: (Integer, Integer)

Feladat: Pontra tükrözés

Tükrözzük a második pontot az első pontra!

mirrorP :: Num a => (a, a) -> (a, a) -> (a, a)

Test>
(-4, -2) :: (Integer, Integer)
Test>
(-2, 0) :: (Integer, Integer)
Test>
(0, 8) :: (Integer, Integer)

Feladat: Két pont távolsága [*]

Számoljuk ki két pont távolságát!

distance :: Floating t => (t, t) -> (t, t) -> t

Test>
True :: Bool

Az abszolút érték függvény:

Test>
Test>
40 :: Integer

A négyzetgyökvonás:

Test>
Test>
True :: Bool

Minták számokra, karakterekre és szövegekre

Különböző típusú értékekre illeszthető minták:

Integer: …, -2, -1, 0, 1, 2, …

Double: …, -2, -1, 0, 1, 2, …, 4.3, …

Char: 'x', '\n', …

String: "", "abc", …

Feladat: Moduló 3 szorzás [*]

Definiáljuk a moduló 3 szorzást mintaillesztéssel!

mul3 :: Int -> Int -> Int

Test>
1 :: Int
Test>
0 :: Int
Test>
2 :: Int

Feladat: Sortörés-szóköz csere

Definiáljunk egy függvényt, amely egy sortörést egy szóközre cserél!

replaceNewline :: Char -> Char

Test>
'x' :: Char
Test>
' ' :: Char
Test>
'y' :: Char

Feladat: Sortörés-szóköz cserék

Definiáljunk egy függvényt, amely minden sortörést szóközre cserél!

replaceNewlines :: String -> String

Test>
" a b c" :: String

Feladat: “a”-“az” csere [*]

Definiáljunk egy függvényt, amely az “a” és “az” szót felcseréli!

swap_a_az :: String -> String

Test>
"az" :: String
Test>
"a" :: String
Test>
"aza" :: String
Test>
"eza" :: String

Feladat: “a”-“az” cserék [*]

Definiáljunk egy függvényt, amely az összes “a” és “az” szót felcseréli!

swapAll_a_az :: String -> String

Test>
"a a az szó" :: String

Segítség: Használjuk a words, unwords függvényeket.

Test>
["az", "az", "alma"] :: [String]
Test>
"az az alma" :: String

Minták listákra

Üres lista minta: []
Egyelemű lista minta: [a]
Kételemű lista minta: [a, b]

Nemüres lista minta: a: b

[] :: [a]
(:) :: a -> [a] -> [a]
Test>
"hello" :: [Char]

Példák (Prelude függvények):

null :: [a] -> Bool
null [] = True
null _  = False
head :: [a] -> a
head (x:xs) = x
tail :: [a] -> [a]
tail (x:xs) = xs

Használat:

Test>
'h' :: Char
Test>
True :: Bool
Test>
"ello" :: [Char]

A listák két alapvető mintája, amelyből felépíthető a többi:

A h:t mintában a h és a t két tetszőleges minta lehet, tehát ez egy összetett minta.

Szemantika:

A kettőspont típusa:

(:) :: a -> [a] -> [a]

Tehát ha h:t típusa [x], akkor h típusa x, t típusa pedig [x].

A kettőspont jobbra köt!

Feladat: 1 elemű-e a lista [*]

Definiáljuk az “1 elemű-e a lista” függvényt mintaillesztéssel!

isSingleton :: [a] -> Bool

Test>
False :: Bool
Test>
True :: Bool

Feladat: Kezdőbetű nagybetűsítés [*]

Egy tetszőleges szót alakítsunk át úgy, hogy nagybetűvel kezdődjön! A megoldásban használjuk a Data.Char modul toUpper függvényét!

toUpperFirst :: String -> String

Test>
"Alma" :: String
Test>
"Alma" :: String

Feladat: Kezdőbetűk nagybetűsítése

Egy tetszőleges szöveg minden szavát alakítsuk át nagybetűvel kezdődőre!

toUpperFirsts :: String -> String

Test>
"A Matematika Alapjai" :: String

Minták halmazkifejezésekben

Minták halmazkifejezésekben is alkalmazhatóak. Erre egy intuitív példa:

Test>
"de" :: [Char]

Feladat: Azonos szavak egy szövegben

Számoljuk meg az “a” szavakat egy szövegben!

countOfAs :: String -> Int

Test>
2 :: Int
Test>
1 :: Int
Test>
0 :: Int

Feladat: Szűrés elemek közti távolság alapján

Számoljuk meg azokat a párokat egy listában, amelyekben a pár elemei közötti távolság legalább 2!

distantPairs :: [(Integer,Integer)] -> Int

Test>
0 :: Int
Test>
1 :: Int
Test>
0 :: Int
Test>
1 :: Int
Test>
2 :: Int

Feladat: A lista minden ötödik eleme

Vegyük egy lista minden 5. elemét!

everyFifth :: [a] -> [a]

Test>
"H e" :: [Char]
Test>
[100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15] :: [Integer]
Test>
[True] :: [Bool]

Megjegyzés: Használhatjuk a zip függvényt.