A Miranda programozási nyelv

Mintaillesztés

Mintaillesztés

A formális paraméterek által meghatározott bal oldalt hívjuk mintának. Ezek a minták vagy értékek (melyek adatkonstruktorokat tartalmaznak) vagy változók. A minták segítségével lehetőség van arra, hogy különbséget tudjunk tenni a függvény definíció baloldalán lévő alternatív egyenlőségek közt. Egy egyenlőség csak akkor alkalmazható, ha minden aktuális argumentum illik a megfelelő mintához. A mintákat balról jobbra, az egyenleteket a szöveg szerint fentről lefelé vizsgáljuk. Ez újabb módszer case megvalósítására, mely gyakran elegánsabb, mint az őrfeltételek használata. A faktoriális definíciója minták segítségével:

fac:: num->num
fac 0 = 1
fac n = n * fac (n-1)

De a minták használhatók az őrökkel kombinálva együttesen is:

fac:: num->num
fac 0 = 1
fac n = n * fac (n-1), n>0
      = error "a függvény 0-nál kisebb argumentummal nem hívható", otherwise

Még néhány példa mintaillesztésre természetes számokon, listákon, tuple-okon (ackerman függvény definíciója):

ack 0 n = n+1
ack (m+1) 0 = ack m 1
ack (m+1) (n+1) = ack m (ack (m+1) n)

Egy naív definíciója a Fibonacci függvénynek:

fib 0 = 0
fib 1 = 1
fib (n+2) = fib (n+1) + fib n

Néhány egyszerű példa listákon használt mintaillesztéssel definiált függvényre:

sum [] = 0
sum (a:x) = a + sum x

product [] = 1
product (a:x) = a * product x

reverse [] = []
reverse (a:x) = reverse x ++ [a]

A tuple elemeinek eléréséhez szintén a mintaillesztést használjuk. Például a kiválasztó függvények kételemű tuple-kon a következőképpen definiálhatóak:

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

Vannak predefinit listakezelő függvények. Ilyen például:

hd:: [num]->num    || head, fej
hd (first:rest) = first

tl:: [num]->[num]    || tail, farok
tl (first:rest) = rest

Végezetül két beépített Miranda függvény definíciója (take és drop), melyek visszaadják egy lista első n elemét vagy az első n-en kívüli maradékot:

take:: num->[*]->[*]
take 0 x = []
take (n+1) [] = []
take (n+1) (a:x) = a : take n x

drop:: num->[*]->[*]
drop 0 x = x
drop (n+1) [] = []
drop (n+1) (a:x) = drop n x

Látható, hogy a két függvény oly módon van definiálva, hogy a következő azonosság minden esetben fennáll: take n x ++ drop n x = x - beleértve azt az extrém esetet is, amikor az x hossza kisebb, mint n.