Grundlagen der Funktionalen Programmierung: Funktionsdefinitionen

Beispiele

	isDigit :: Char -> Bool isDigit c = c >= '0' && c <= '9'
	Diese Funktion ist vordefiniert in Data.Char

	even :: Integral a => a -> Bool even n = n `mod` 2 == 0
	Diese Funktion ist im Prelude vordefiniert

	splitAt :: Int -> [a] -> ([a], [a]) splitAt n xs = (take n xs, drop n xs)
	Diese Funktion ist im Prelude vordefiniert

Verzweigungen
Syntax	if e1 then e2 else e3
	abs :: (Ord a, Num a) => a -> a abs n = if n >= 0 then n else negate n -- mehrzeilig mit Einrückung abs n = if n >= 0 then n else -n -- negate n

	signum :: Num a => a -> a signum n = if n < 0 then -1 else if n > 0 then 1 else 0
	Unübersichtlich: Geschachtelte Verzweigungen

Wächter	Alternative Syntax für Verzweigungen
	Regelartige Syntax

	abs n \| n >= 0 = n \| otherwise = -n signum n \| n < 0 = -1 \| n > 0 = 1 \| n == 0 = 0

Mehrweg-Verzweigungen	durch case-Ausdrücke
	data Ordering = LT \| EQ \| GT compare :: Ord a => a -> a -> Ordering signum n = case compare n 0 of LT -> -1 EQ -> 0 GT -> 1

Verzweigungen	durch Mustervergleich (pattern matching)
	not :: Bool -> Bool -- .1 not x = if x then False else True -- .2 not False = True not True = False -- .3 not False = True not _ = False

	(&&) :: Bool -> Bool -> Bool True && True = True True && False = False False && True = False False && False = False -- oder True && True = True _ && _ = False -- oder True && b = b False && _ = False -- oder a && b = if a then b else False

Muster	für Tupel
	fst :: (a, b) -> a fst (x, _) = x snd :: (a, b) -> b snd (_, y) = y

Muster	für Listen
	null :: [a] -> Bool null [] = True null _ = False head :: [a] -> a head (x : _) = x test1 :: [Char] -> ... test1 ['a'] = ... test1 ['a', 'b', 'c'] = ... test1 "abc" = ... test1 ('a' : 'b' : 'c' : cs) = ... test1 [_, 'b', _] = ... test1 (c1 : 'b' : c3 : []) = ... test1 xs = ...

Zwischenergebnisse	mit where-Klauseln
	odds :: Int -> [Int] odds n = map f [0 .. n1] where n1 = n - 1 f x = 2 * x + 1 map :: (a -> b) -> [a] -> [b] -- vordefiniert

module FctDef
where
import Prelude hiding ( splitAt
                      , recip
                      , abs
                      , signum
                      , not
                      , fst, snd
                      , null, head, tail
                      , const
                      , even
                      )
import qualified Prelude as P
-- Funktionsdefinitionen
isDigit :: Char -> Bool
isDigit c
    = c >= '0' && c <= '9'
even :: Integral a => a -> Bool
even n
    = n `mod` 2 == 0
splitAt :: Int -> [a] -> ([a], [a])
splitAt n xs
    = (take n xs, drop n xs)
recip :: Fractional a => a -> a
recip x = 1 / x
-- Verzweigungen
abs n
    = if n >= 0
      then n
      else -n
signum n
    = if n < 0
      then -1
      else if n == 0
           then 0
           else 1
-- Waechter (guards)
abs' n
    | n >= 0    = n
    | otherwise = -n
signum' n
    | n <  0 = -1
    | n == 0 =  0
    | n >  0 =  1
-- Typen von abs, signum ?
-- Mustervergleiche (pattern matching)
not :: Bool -> Bool
not x
    = if x then False else True
not' False = True
not' True  = False
not'' False = True
not'' _     = False
(&&&) :: Bool -> Bool -> Bool
False &&& False = False
False &&& True  = False
True  &&& False = False
True  &&& True  = True
(.&&.) :: Bool -> Bool -> Bool
True .&&. True = True
_    .&&. _    = False
(<&&>) :: Bool -> Bool -> Bool
True  <&&> b = b
_     <&&> _ = False
(&&&&) :: Bool -> Bool -> Bool
a &&&& b = if a
           then b
           else False
fst (x, _) = x
snd (_, y) = y
-- Typen von fst und snd?
test1 ['a', _, _] = True
test1 _           = False
-- Typ von test1?
null :: [t] -> Bool
null [] = True
null _  = False
head :: [t] -> t
head (x : _) = x
head [] = error "hahahahahah"
tail :: [t] -> [t]
tail (_ : xs) = xs
-- lambda-Ausdruecke
l1 = \ x -> x + x
l2 = (\ x -> x + x) 2
l3 = (\ x -> x + x) (2 + 3)
l4 = \ x -> (\ y -> x + y)
-- Funktionen als Resultat
const :: a -> b -> a
const c _x = c
const' :: a -> (b -> a)
const' c = \ _x -> c
-- Funktionen als Argument
odds :: Int -> [Int]
odds n
    = map f [0..n-1]
      where
        f x = 2 * x + 1
-- :t map ?
odds' n
    = map (\ x -> 2 * x + 1) [0..n-1]
-- :t odds' ?
-- :t (1+)
-- :t (*2)
-- :t (== 1)
-- :t (1 <)

Funktionsdefinitionen

Beispiele zum Kapitel

Die Quelle