Slideshare uses cookies to improve functionality and performance, and to provide you with relevant advertising. If you continue browsing the site, you agree to the use of cookies on this website. See our User Agreement and Privacy Policy.

Slideshare uses cookies to improve functionality and performance, and to provide you with relevant advertising. If you continue browsing the site, you agree to the use of cookies on this website. See our Privacy Policy and User Agreement for details.

Like this presentation? Why not share!

- 06. haskell type builder by Sebastian Rettig 370 views
- 05. haskell streaming io by Sebastian Rettig 541 views
- 01. haskell introduction by Sebastian Rettig 1154 views
- 04. haskell handling by Sebastian Rettig 470 views
- 03. haskell refresher quiz by Sebastian Rettig 584 views
- 02. haskell motivation by Sebastian Rettig 655 views

No Downloads

Total views

401

On SlideShare

0

From Embeds

0

Number of Embeds

1

Shares

0

Downloads

12

Comments

0

Likes

1

No embeds

No notes for slide

- 1. Functions Sebastian RettigEvery 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)● lets 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● lets 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)● lets 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: Learn you 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)

No public clipboards found for this slide

×
### Save the most important slides with Clipping

Clipping is a handy way to collect and organize the most important slides from a presentation. You can keep your great finds in clipboards organized around topics.

Be the first to comment