Upcoming SlideShare
×

532 views

Published on

Published in: Technology
1 Like
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
532
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
11
0
Likes
1
Embeds 0
No embeds

No notes for slide

1. 1. Modules Sebastian RettigA Haskell module is aa collection of related functions, A Haskell module is collection of related functions, types and typeclasses. types and typeclasses.
2. 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. 3. Haskell Features● Pure Functional Programming Language● Lazy Evaluation● Pattern Matching and Guards● List Comprehension● Type Polymorphism● Curried Functions
4. 4. Nice to remember (1) Applicative Context: – Maybe, Either for things which can fail – [] as non-deterministic result – IO as values send or get from outside● Applicative functors allows us to operate in applicative types like normal types and provide the context!● → We dont need to pattern match against the Context in every operation we use in our functions!
5. 5. Nice to remember (2) Typeclasses:● define properties of the types● an interface for types who have some behavior in common: – Eq can be compared – Ord can be ordered (>, <, >=, <=) (extending Eq) – Show can be shown as string – Read opposite of Show – Functor something that can be mapped over – Applicative handle functions wrapped in a Functor
6. 6. Nice to remember (3) 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]
7. 7. Nice to remember (4) Curried Function:● every function in haskell consumes exactly one parameter and returns a value● PARTIAL APPLICATION● 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)
8. 8. Nice to remember (5) Pointless Style:● based on partial Application → simpler code maxWithFour x = max 4 x is the same as maxWithFour = max 4● use Function Application (\$) to avoid Parenthesis on function call with parameters sqrt \$ 3 + 4 + 9● use Function Composition (.) to avoid Parenthesis on chaining functions fn = ceiling . negate . tan . cos . max 50
9. 9. Nice to remember (6) Kind:● explains the steps which are necessary to evaluate the data from that type● → evaluate = the type is fully applied● can be used to find out the parameter-count of a type● GHCi- Command :k● :k Int returns Int :: *● data MyVector4 a b c = Nirvana4 | Single4 {x :: a} | Tuple4 {x :: a, y :: b} | Triple4 {x :: a, y :: b, z :: c} :k MyVector4 returns MyVector4 :: * -> * -> * -> *
10. 10. Nice to remember (7) DO-Notation: main :: IO () main = do putStrLn “Say me your Name!” name <- getLine putStrLn \$ “Hello” ++ name● do syntax glues IO actions together● bind operator <- get the data out of IO and bind result to a placeholder● :t getLine returns getLine :: IO String – name has the type String● ! The last action in a do-block can not be bound !
11. 11. Nice to remember (8) Fold & Scan:● foldl :: (a -> b -> a) -> a -> [b] -> a● foldr :: (a -> b -> b) -> b -> [a] -> b● scanl :: (a -> b -> a) -> a -> [b] -> [a]● scanr :: (a -> b -> b) -> b -> [a] -> [b]● folding is a general approach for simple recursion● scan is like fold, but returns the accumulator state of every recursion step instead of the accumulator
12. 12. Modules (1)● types and functions are managed in modules● main module can load other modules● prelude.hs loads mostly used modules on startup● import modules at the beginning of a File: import Data.List● Selective Import of only some functions of module import Data.List (nub, sort) – import only functions nub and sort – import Data.List hiding (nub) – import all functions but not nub
13. 13. Modules (2)● use qualified imports if you have name conflicts● often occurs on import modules which are already selective imported by prelude.hs import Data.Map as M – use reference to call qualified imports, e.g. M.filter (>5) [3,6,2]
14. 14. Modules (3)● create own modules, e.g. File Geometry.hs module Geometry ( sphereVolume , sphereArea ) where //Implementation● modules in a namespace must be in same parent Folder, e.g. module Geometry.Sphere ( volume , area ) where – Sphere.hs in folder Geometry
15. 15. Functor Typeclass (1) class Functor f where fmap :: (a -> b) -> f a -> f b● general Interface for things that can be mapped over● !!! Functor needs Types with kind * -> * !!!● fmap gets a function and a type and maps the function over the type variable● Instance for List: instance Functor [] where fmap = map – Example: fmap (*2) [2,3,4] returns [4,6,8]
16. 16. 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)
17. 17. Functor Typeclass (3) 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 Just (4+)● → we need an extension → Applicative Functors
18. 18. Applicative Functor (1) class (Functor f) => Applicative f where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b● pure is a function who wraps a normal value into applicative – creates a minimal context● (<*>) takes a functor with a function in it and another functor – extracts that function from the first functor – and then maps it over the second one● pure f <*> x equals fmap f x → specific function exists: (<\$>) :: (Functor f) => (a -> b) -> f a -> f b f <\$> x = fmap f x
19. 19. Applicative Functor (2)● Instance for Maybe instance Applicative Maybe where pure = Just Nothing <*> _ = Nothing (Just f) <*> something = fmap f something● Instance for IO instance Applicative IO where pure = return a <*> b = do f <- a x <- b return (f x)
20. 20. Applicative Functor (3) Examples:● Just (+3) <*> Just 9 returns Just 12● pure (+3) <*> Just 10 returns Just 13● Just (++"hah") <*> Nothing returns Nothing● [(+100),(^2)] <*> [1,2,3] returns [101,102,103,1,4,9]● pure "Hey" :: [String] returns ["Hey"]● [(+),(*)] <*> [1,2] <*> [3,4] returns [4,5,5,6,3,4,6,8]● (++) <\$> Just "foo" <*> Just "bar" returns Just "foobar"● main = do a <- (++) <\$> getLine <*> getLine putStrLn \$ "The two lines concatenated is: " ++ a
21. 21. Lifting a Function (Functor)● if we partial apply fmap, the header has the following structure :t fmap (*2) results in fmap (*2) :: (Num a, Functor f) => f a -> f a :t fmap (cycle 3) results in fmap (cycle 3) :: (Functor f) => f a -> f [a]● → this is called lifting a function● → we can predefine a function which gets a Functor and returns a functor● → that means, we can bring normal functions inside the Wrapper (Context)● → we lift the function up into the Context
22. 22. Lifting a Function (Applicative)● liftA :: Applicative f => (a -> b) -> f a -> f b – same as fmap – fmap :: Functor f => (a -> b) -> f a -> f b● liftA2 :: (Applicative f) => (a -> b -> c) -> f a -> f b -> f c liftA2 f a b = f <\$> a <*> b – gets a function, with 2 parameters – operates on 2 Applicatives – result is also an Applicative