08. haskell Functions

08. haskell Functions

• 1.
  Functions Sebastian Rettig Every function in haskell consumes exactly Every function in haskell consumes exactly one parameter and returns aa value. one parameter and returns value.
• 2.
  Functional Programming ● No Variables ● Functions only, eventually stored in Modules – Behavior do not change, once defined – → Function called with same parameter calculates always the same result ● Function definitions (Match Cases) ● Recursion (Memory)
• 3.
  Haskell Features ● Pure Functional Programming Language ● Lazy Evaluation ● Pattern Matching and Guards ● List Comprehension ● Type Polymorphism
• 4.
  Nice to remember(1) Typeclasses: ● define properties of the types ● like an interface – Eq can be compared – Ord can be ordered (>, <, >=, <=) (extending Eq) – Show can be shown as string – Read opposite of Show – Enum sequentially ordered types (can be enumerated and usable in List-Ranges ['a'..'e'])
• 5.
  Nice to remember(2) Typeclass-Membership: 1. derive from existing Memberships of used types data Vector2D = Vector Float Float deriving (Show, Eq) 2. implement Membership by your own instance Show Vector2D where show Vector a b = “x: ” ++ [a] ++ “ ; y: ” ++ [b]
• 6.
  Curried Functions (1) ● let's look at the Function header again, e.g: max :: (Ord a) => a -> a -> a 1. we have a Typeclass restriction for Ord 2. we have 2 Parameters of Types, who have a membership for the Ord Typeclass 3. we have a return value of the same type ● But, why is the syntax not separating the parameters better from the result set?
• 7.
  Curried Functions (2) ● every function in haskell consumes exactly one parameter and returns a value ● so we could write the function header instead of: max :: (Ord a) => a -> a -> a ● also in the following way: max :: (Ord a) => a -> (a -> a) – max is a function which consumes a parameter and returns a function – these function consumes a parameter and returns a value (the max of both values) ● → Partial Application
• 8.
  Curried Functions (3) ● some examples: – :t max returns max :: (Ord a) => a -> a -> a – max 4 5 returns 5 – (max 4) 5 returns 5 – :t max 4 returns max 4 :: (Num a, Ord a) => a -> a – let foo = max 4 foo 5 returns 5 – :t max 4 5 returns max 4 5 :: (Num a, Ord a) => a
• 9.
  Curried Functions (4) ● we can also partial apply infix functions (/10) 2 returns 0.2 (10/) 2 returns 5 (++ “bar”) “foo” returns “foobar” (“bar” ++) “foo” returns “barfoo” :t (`elem` ['a'..'z']) (`elem` ['a'..'z']) :: Char -> Bool :t ('a' `elem`) (`elem` ['a'..'z']) :: [Char] -> Bool :t elem elem :: Eq a => a -> [a] -> Bool
• 10.
  Pointless Style ● let's say, we have the following function: maxWithFour :: (Num a, Ord a) => a -> a maxWithFour x = max 4 x ● what is the result of max 4 again? :t max 4 returns max 4 :: (Num a, Ord a) => a -> a ● max 4 returns already a function which consumes a parameter, so we can simplify our function: maxWithFour :: (Num a, Ord a) => a -> a maxWithFour = max 4 ● but how can we achieve that with the following function? fn x = ceiling (negate (tan (cos (max 50 x))))
• 11.
  Function Application (1) ● used with ($) ● has the following header: :t ($) ($) :: (a -> b) -> a -> b ● compared with SPACE (normal function application) – ($) has lowest priority – ($) is right associative f $ g $ a b = (f (g (a b))) – SPACE has highest priority – SPACE is left associative f a b c = (((f a) b) c)
• 12.
  Function Application (2) ● what can we do with ($) ? ● helps us to avoid parentheses: – instead of: sum (map sqrt [1..20]) – we can write: sum $ map sqrt [1..20] ● allows us also to wrap a value in a function: map ($ 3) [(4+), (10*), (^2), sqrt] returns [7.0,30.0,9.0,1.7320508075688772]
• 13.
  Function Composition (1) ● Definition: ● used with (.) ● has the following header: :t (.) (.) :: (b -> c) -> (a -> b) -> a -> c ● composing two functions produces a new function ● good for on-the-fly pass of a function to the next function
• 14.
  Function Composition (2) ● what can we do with (.) ? ● helps us also to avoid parentheses ● → unwraps the parameter out of parentheses – instead of: map (xs -> negate (sum (tail xs))) [[1..5], [3..6],[1..7]] – we can write: map (negate . sum . tail) [[1..5],[3..6], [1..7]]
• 15.
  Composition vs. Application(1) ● IMPORTANT to know the difference between ($) and (.) ● best to compare both headers again: – ($) :: (a -> b) -> a -> b – (.) :: (b -> c) -> (a -> b) -> a -> c ● combination of both allows us parenthesis-less writing ● shorter code and mostly easier to read ● → possibility to write pointless-style functions with more then one function call
• 16.
  Composition vs. Application(2) ● example with parameter: – foo xs = sum (filter (> 10) (map (*2) xs)) – foo xs = sum $ filter (> 10) $ map (*2 ) xs ● example without parameter (pointless-style): – foo xs = sum (filter (> 10) (map (*2) xs)) – foo = sum . filter (> 10) . map (*2)
• 17.
  Useful Types ● Maybe: data Maybe a = Nothing | Just a – contains maybe a type a or Nothing – good for handling e.g. Hashmap lookup ● Nothing if key not exist, else Value of type a ● Either: data Either a b = Left a | Right b deriving (Eq, Ord, Read, Show) – can contain type a or type b – Left for e.g. Error Messages, Right for value – like an extended Maybe with information for Nothing
• 18.
  Functor Typeclass (1) class Functor f where fmap :: (a -> b) -> f a -> f b ● for things that can be mapped over ● !!! Functor needs Types with 1 Typeparameter !!! ● fmap gets a function and a type and maps the function over the type variable ● Instance for List: – Remember: List has 1 Typeparameter [a], but is just Syntactic Sugar for ([] a) instance Functor [] where fmap = map – Example: fmap (*2) [2,3,4] returns [4,6,8]
• 19.
  Functor Typeclass (2) class Functor f where fmap :: (a -> b) -> f a -> f b ● Instance for Maybe instance Functor Maybe where fmap g (Just x) = Just (g x) fmap g Nothing = Nothing ● Example: – fmap (+3) Nothing returns Nothing – fmap (+3) (Just 4) returns (Just 7)
• 20.
  Functor Typeclass (3) class Functor f where fmap :: (a -> b) -> f a -> f b ● Instance for Either instance Functor (Either a) where fmap f (Right x) = Right (f x) fmap f (Left x) = Left x ● Either is a type with 2 Typeparameters! ● → we have to permanently include the first parameter in the instance (curried function, partial application) ● → fmap do not change the 1st Typeparameter, only the 2nd ● → Left Type-Constructor of Either is often used for Error Messages
• 21.
  Functor Typeclass (4) class Functor f where fmap :: (a -> b) -> f a -> f b ● Example: – fmap (+3) (Left 4) returns (Left 4) – fmap (+3) (Right 4) returns (Right 7) ● what happens, if we try to do that? fmap (+) (Just 4) ● let's look at the type: :t fmap (+) (Just 4) fmap (+) (Just 4) :: Num a => Maybe (a -> a) ● partial application, BUT we can not use the Functor instance on the result! ● → we need an extension → Applicative Functors
• 22.
  Sources [1] Haskell-Tutorial: Learnyou a Haskell (http://learnyouahaskell.com/, 2012/03/15) [2] The Hugs User-Manual ( http://cvs.haskell.org/Hugs/pages/hugsman/index.html, 2012/03/15) [3] The Haskellwiki (http://www.haskell.org/haskellwiki, 2012/03/15)