Haskell Revision and Exercises

Transcription

1 and Exercises April 10, 2017 Martin Perešíni Haskell Revision and Exercises April 10, / 53

2 Content Content Content Haskell Revision Types and Typeclasses Types of Functions List of types Syntax in functions Recursion Recursion performance Higher order functions map filter Lambda function foldl Modules Making our own Modules Making our own Types Input / Output Files and streams Exercises XOR operation Spiral matrix Find sublist in list Decimal to Binary Complex numbers Sierpinski triangle Permutations Solutions XOR operation Spiral matrix Find sublist in list Decimal to Binary Complex numbers Sierpinski triangle Permutations Questions? Martin Perešíni Haskell Revision and Exercises April 10, / 53

3 Haskell Revision Martin Perešíni Haskell Revision and Exercises April 10, / 53

4 Types and Typeclasses Types and Typeclasses Haskell has safe static type system ghci> :t 'a' 'a' :: Char ghci> :t True True :: Bool ghci> :t "HELLO!" "HELLO!" :: [Char] ghci> :t (True, 'a') (True, 'a') :: (Bool, Char) ghci> :t 4 == 5 4 == 5 :: Bool Martin Perešíni Haskell Revision and Exercises April 10, / 53

5 Types of Functions Types of Functions / Prototypes Typeclass of function, prototype, signature of function addthree :: Int -> Int -> Int -> Int addthree x y z = x + y + z factorial :: Integer -> Integer factorial n = product [1..n] Martin Perešíni Haskell Revision and Exercises April 10, / 53

6 List of types List of types Int - bounded integer,32-bit, Int max is 2,147,483,647 (2 31 1) and the min is -2,147,483,648 ( 2 31 ) Integer - unbounded integer, for representing really big numbers Float - floating point number with single precision Double - floating point number with double precision Bool - boolean type, True or False Char - represent a character, eq. a, X, ;,?,... a - type variable, can be any type, it s used in function signatures operator - typeclass, interface, special case like operators, == equality, +, -,... Num - numeric typeclass, property of acting like numbers Martin Perešíni Haskell Revision and Exercises April 10, / 53

7 Syntax in functions Syntax in functions Signature - first, we need to make sure which type our function will produce and which type of parameters functions accept, sometimes a Haskell can decide instead of us signature of function on basis of defined function (real implemented) Definition of function - our implementation part of writing function lucky :: (Integral a) => a -> String lucky 7 = "LUCKY NUMBER SEVEN!" lucky x = "Sorry, you're out of luck, pal!" Martin Perešíni Haskell Revision and Exercises April 10, / 53

8 Syntax in functions Syntax in functions - Examples capital :: String -> String capital "" = "Empty string, whoops!" capital all@(x:xs) = "The first letter of " ++ all ++ " is " ++ [x] max' :: (Ord a) => a -> a -> a max' a b a > b = a otherwise = b bmitell :: (RealFloat a) => a -> a -> String bmitell weight height bmi <= 18.5 = "You're underweight, you emo, you!" bmi <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!" bmi <= 30.0 = "You're fat! Lose some weight, fatty!" otherwise = "You're a whale, congratulations!" -- important PART, WHERE simplified our function where bmi = weight / height ^ 2 Martin Perešíni Haskell Revision and Exercises April 10, / 53

9 Recursion Recursion Recursion when a function in it s own definition use in terms of itself (calling themselves), there need to be and ending condition, elsewhere there will be infinite recursion Recursion is as powerfull as iteration, disadvantages are more space consumption and sometimes bigger time complexity on other hand recursion is more friendlier for reading and understanding algorithm behind defined recurrent function fib::int->int fib 0 = 0 fib 1 = 1 fib n = fib (n-1) + fib (n-2) Martin Perešíni Haskell Revision and Exercises April 10, / 53

10 Recursion Recursion - continue maximum' :: (Ord a) => [a] -> a maximum' [] = error "maximum of empty list" maximum' [x] = x maximum' (x:xs) = max x (maximum' xs) Martin Perešíni Haskell Revision and Exercises April 10, / 53

11 Recursion Recursion - continue quicksort :: (Ord a) => [a] -> [a] quicksort [] = [] quicksort (x:xs) = let smallersorted = quicksort [a a <- xs, a <= x] biggersorted = quicksort [a a <- xs, a > x] in smallersorted ++ [x] ++ biggersorted Martin Perešíni Haskell Revision and Exercises April 10, / 53

12 Recursion performance List reversion, performance of recursive functions tail direct recursion O(n 2 ), slower forward indirect recursion O(n) rev' :: [a] -> [a] rev' [] = [] rev' (x:xs) = rev' xs ++ [x] reverse' :: [a] -> [a] reverse' xs = rev' xs [] where rev' [] ys = ys rev' (x:xs) ys = rev' xs (x:ys) Martin Perešíni Haskell Revision and Exercises April 10, / 53

13 Recursion performance List reversion performance set debug ghci ghci> :set +s real performance we can clearly see the difference rev' [ ] (1.84 secs, 4,337,437,960 bytes) reverse' [ ] (0.16 secs, 44,556,984 bytes) Martin Perešíni Haskell Revision and Exercises April 10, / 53

14 Higher order functions Higher order functions, currying Haskell functions can take functions as parameters and return functions as return values. Curried functions means that every function in Haskell officially only takes one parameter. How then we can use multiparameter functions? Simply it s just composition of function and return parameters apply again function. Example: -- same result, example of currying ghci> max 4 5 ghci> (max 4) 5 Martin Perešíni Haskell Revision and Exercises April 10, / 53

15 Higher order functions Higher order functions example Example of higher order function, return another function instead of raw value. multthree :: (Num a) => a -> a -> a -> a multthree x y z = x * y * z ghci> let multtwowithnine = multthree 9 ghci> multtwowithnine result ghci> let multwitheighteen = multtwowithnine 2 ghci> multwitheighteen result Martin Perešíni Haskell Revision and Exercises April 10, / 53

16 Higher order functions Higher order functions more examples applytwice :: (a -> a) -> a -> a applytwice f x = f (f x) ghci> applytwice (+3) result ghci> applytwice (++ " HAHA") "HEY" "HEY HAHA HAHA" --result zipwith' :: (a -> b -> c) -> [a] -> [b] -> [c] zipwith' _ [] _ = [] zipwith' [] = [] zipwith' f (x:xs) (y:ys) = f x y : zipwith' f xs ys ghci> zipwith' (+) [4,2,5,6] [2,6,2,3] [6,8,7,9] --result ghci> zipwith' max [6,3,2,1] [7,3,1,5] [7,3,2,5] --result Martin Perešíni Haskell Revision and Exercises April 10, / 53

17 map Map map takes a function and a list and applies that function to every element in the list, producing a new list. map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs ghci> map (+3) [1,5,3,1,6] [4,8,6,4,9] --result ghci> map (++ "!") ["BIFF", "BANG", "POW"] ["BIFF!","BANG!","POW!"] --result ghci> map (replicate 3) [3..6] [[3,3,3],[4,4,4],[5,5,5],[6,6,6]] --result ghci> map (map (^2)) [[1,2],[3,4,5,6],[7,8]] [[1,4],[9,16,25,36],[49,64]] --result Martin Perešíni Haskell Revision and Exercises April 10, / 53

18 filter Filter filter is a function that takes a predicate (a predicate is a function that tells whether something is true or not, so in our case, a function that returns a boolean value) and a list and then returns the list of elements that satisfy the predicate. filter :: (a -> Bool) -> [a] -> [a] filter _ [] = [] filter p (x:xs) p x = x : filter p xs otherwise = filter p xs ghci> filter (>3) [1,5,3,2,1,6,4,3,2,1] [5,6,4] --result ghci> filter (==3) [1,2,3,4,5] [3] --result ghci> filter ('elem' ['a'..'z']) "LaUgH at me BeCaUsE" "agameas" --result Martin Perešíni Haskell Revision and Exercises April 10, / 53

19 Lambda function Lambda function Lambdas are anonymous functions. They are used because sometimes we need some functions use only once, so there is no need to write whole function with name and signature. -- this is lambda -- vvvvvvvvvvvvvvvvvvvvvvvv ghci> zipwith (\a b -> (a * ) / b) [5,4,3,2,1] [1,2,3,4,5] [153.0,61.5,31.0,15.75,6.6] -- this is lambda -- vvvvvvvvvvvvvvv ghci> map (\(a,b) -> a + b) [(1,2),(3,5),(6,3),(2,6),(2,5)] [3,8,9,8,7] -- normal addthree addthree :: (Num a) => a -> a -> a -> a addthree x y z = x + y + z -- addthree with lambdas addthree :: (Num a) => a -> a -> a -> a addthree = \x -> \y -> \z -> x + y + z -- ^^ ^^ ^^ -- lambdas Martin Perešíni Haskell Revision and Exercises April 10, / 53

20 foldl Foldl foldl function, also called the left fold. It folds the list up from the left side. The binary function is applied between the starting value and the head of the list. That produces a new accumulator value and the binary function is called with that value and the next element, etc. Demonstration on sum function. Martin Perešíni Haskell Revision and Exercises April 10, / 53

21 foldl Foldl example -- first variation of sum' sum' :: (Num a) => [a] -> a sum' xs = foldl (\acc x -> acc + x) 0 xs ghci> sum' [3,5,2,1] 11 --result -- second variation of sum' sum' :: (Num a) => [a] -> a sum' = foldl (+) 0 ghci> sum' [3,2,6,7,8] 26 --result ghci> sum' [3.2,2.1,6.8,7.1,-8.2,-66.66] result Martin Perešíni Haskell Revision and Exercises April 10, / 53

22 Modules Modules A Haskell module is a collection of related functions, types and typeclasses. A classical Haskell program is a collection of modules where the main module loads up the other modules and then uses the functions defined in them to do something. Having code split up into several modules has quite a lot of advantages. If a module is generic enough, the functions it exports can be used in a multitude of different programs. Important part is also namespaces of module functions because we could have functions with same name in different modules but semantics of fuctions are different. Load of module as import or interactive ghci: import Data.List -- :module or shorter :m ghci> :m + Data.List Data.Map Data.Set Martin Perešíni Haskell Revision and Exercises April 10, / 53

23 Making our own Modules Making our own Modules At the beginning of a module, we specify the module name. Then we declare our functions and after that we define our functions or data structures. Like in C/C++/Python or others programming languages. If we have a file called Geometry.hs, then we should name our module Geometry. Then, we specify the functions that it exports and after that, we can start writing the functions. Whole Geometry.hs is presented on next slide. Martin Perešíni Haskell Revision and Exercises April 10, / 53

24 Making our own Modules module Geometry ( spherevolume, spherearea, cubevolume, cubearea, cuboidarea, cuboidvolume ) where spherevolume :: Float -> Float spherevolume radius = (4.0 / 3.0) * pi * (radius ^ 3) spherearea :: Float -> Float spherearea radius = 4 * pi * (radius ^ 2) cubevolume :: Float -> Float cubevolume side = cuboidvolume side side side cubearea :: Float -> Float cubearea side = cuboidarea side side side cuboidvolume :: Float -> Float -> Float -> Float cuboidvolume a b c = rectanglearea a b * c cuboidarea :: Float -> Float -> Float -> Float cuboidarea a b c = rectanglearea a b * 2 + rectanglearea a c * 2 + rectanglearea c b * 2 rectanglearea :: Float -> Float -> Float rectanglearea a b = a * b Martin Perešíni Haskell Revision and Exercises April 10, / 53

25 Making our own Modules We use our created module like this. -- we need to load our Geometry haskell script Prelude> :l Geometry.hs [1 of 1] Compiling Geometry ( Geometry.hs, interpreted ) Ok, modules loaded: Geometry. -- we need import loaded Geometry module *Geometry> :m + Geometry -- use function spherearea from our Geometry module *Geometry Geometry> Geometry.sphereArea result -- show all available Geometry functions started with "cub" *Geometry Geometry> Geometry.cub Geometry.cubeArea Geometry.cuboidArea Geometry.cubeVolume Geometry.cuboidVolume -- another example of using function from Geometry module *Geometry Geometry> Geometry.cuboidVolume result Martin Perešíni Haskell Revision and Exercises April 10, / 53

26 Making our own Types Making our own Types and Typeclasses Similar like making modules - set of functions we can create our own data types or typeclasses. Let s try define our own data type of Circle or Rectangle. data Shape = Circle Float Float Float Rectangle Float Float Float Float ghci> :t Circle Circle :: Float -> Float -> Float -> Shape ghci> :t Rectangle Rectangle :: Float -> Float -> Float -> Float -> Shape define our function for calculating surface of object Circle or Rectangle surface :: Shape -> Float surface (Circle r) = pi * r ^ 2 surface (Rectangle x1 y1 x2 y2) = (abs $ x2 - x1) * (abs $ y2 - y1) Martin Perešíni Haskell Revision and Exercises April 10, / 53

27 Making our own Types Now let s try if it s working in real: ghci> surface $ Circle result ghci> surface $ Rectangle result Wonderful, it s working ;). Try to define type for store Person data like this. data Person = Person { firstname :: String, lastname :: String, age :: Int, height :: Float, phonenumber :: String, flavor :: String } deriving (Show) Martin Perešíni Haskell Revision and Exercises April 10, / 53

28 Again let s try if it s working in real: Making our own Types ghci> let bloke = Person "Übermensch" "Crackerjack" " " "Über" ghci> firstname bloke "Übermensch" --result ghci> height bloke result Ok, just one more, try to define vector of 3 dimensions (3D) representating of objects. data Vector a = Vector a a a deriving (Show) scalarmult :: (Num t) => Vector t -> Vector t -> t (Vector i j k) 'scalarmult' (Vector l m n) = i*l + j*m + k*n ghci> Vector 'scalarmult' Vector result Martin Perešíni Haskell Revision and Exercises April 10, / 53

29 Input / Output Input / Output Of course in Haskell we need to perform some IO() operations. For that purpose we had special type of IO(). Example: ghci> :t putstrln putstrln :: String -> IO () ghci> :t putstrln "hello, world" putstrln "hello, world" :: IO () We can read the type of putstrln as that it takes a string and returns an I/O action that has a result type of (). Notice that the empty tuple had value of () and it is also a type of (). Martin Perešíni Haskell Revision and Exercises April 10, / 53

30 Input / Output Example of simple IO program main = do putstrln "Hello, what's your name?" name <- getline putstrln ("Hey " ++ name ++ ", you rock!") Each of these steps is an I/O action. By putting them together with do syntax, we glued them into one I/O action. The action that we got has a type of IO (), because that s the type of the last I/O action inside. ghci> :t getline getline :: IO String Martin Perešíni Haskell Revision and Exercises April 10, / 53

31 Input / Output String is different then IO String so we cannot do something like this, concatenating string variable with getline string! WRONG concatenating with IO() action! non valid nametag = "Hello, my name is " ++ getline another example main = do line <- getline if null line then return () else do putstrln $ reversewords line main reversewords :: String -> String reversewords = unwords. map reverse. words Martin Perešíni Haskell Revision and Exercises April 10, / 53

32 Input / Output So how is it possible to be able print string to our monitor screen? Simple, we use special instance Show which know, how to represent string. Finnaly then there is called corresponding function for printing things on monitor screen. For example functions data typesputstr or putchar or print main = do putstr "Hey, " putstr "I'm " putstrln "Andy!" main = do putchar 't' putchar 'e' putchar 'h' Martin Perešíni Haskell Revision and Exercises April 10, / 53

33 Input / Output main = do print True print 2 print "haha" print 3.2 print [3,4,3] import Control.Monad main = do colors <- form [1,2,3,4] (\a -> do putstrln $ "Which color do you associate with the number " ++ show a ++ "?" color <- getline return color) putstrln "The colors that you associate with 1,2,3 and 4 are: " mapm putstrln colors Martin Perešíni Haskell Revision and Exercises April 10, / 53

34 Input / Output Expected result of previous example IO() actions Which color do you associate with the number 1? white Which color do you associate with the number 2? blue Which color do you associate with the number 3? red Which color do you associate with the number 4? orange The colors that you associate with 1, 2, 3 and 4 are: white blue red orange Martin Perešíni Haskell Revision and Exercises April 10, / 53

35 Files and streams Files and streams And what about files and streams, how to work with them in Haskell? First option is pipe input from command line like pretend to be normal keyboard input (unix style) or second option is open file and get content of file. import System.IO main = do handle <- openfile "somefile.txt" ReadMode contents <- hgetcontents handle putstr contents hclose handle Martin Perešíni Haskell Revision and Exercises April 10, / 53

36 Files and streams FilePath is just a type synonym for String, simply defined as: type FilePath = String IOMode is a type that s defined like this: data IOMode = ReadMode WriteMode AppendMode ReadWriteMode Conclusion is it very similar to other programming languages, we had file handler and it s need to be open or closed and we had modes for that handler and also streams like in C++/Python and so on. Martin Perešíni Haskell Revision and Exercises April 10, / 53

37 Exercises Exercises Martin Perešíni Haskell Revision and Exercises April 10, / 53

38 Exercises XOR operation XOR operation - task Define logical XOR operation, function in haskell show XOR solution ghci> xor True False True --result ghci> xor True True False --result ghci> xor False False False --result ghci> xor False True True --result Martin Perešíni Haskell Revision and Exercises April 10, / 53

39 Exercises Spiral matrix Spiral matrix - task Define function that print each matrix element in spiral matrix traversal toward centre of matrix. For example, print path of 3x3 matrix like this. Result 1,2,3,6,9,8,7,4,5. show Spiral matrix solution Martin Perešíni Haskell Revision and Exercises April 10, / 53

40 Exercises Find sublist in list Find sublist in list - task Define function findlist which finds starting position of sublist in a list, example how it s has to work: show find sublist in list solution ghci> findlist "tst" "abctstdef" Just 3 --result ghci> findlist "test" "abctstdef" Nothing --result ghci> findlist [1] [4,5,1,2,5,1] Just 2 --result ghci> findlist [] [4,5,1,2,5,1] Just 0 --result ghci> findlist [4] [4,5,1,2,5,1] Just 0 --result ghci> findlist [7] [4,5,1,2,5,1] Nothing --result Martin Perešíni Haskell Revision and Exercises April 10, / 53

41 Exercises Decimal to Binary Decimal to Binary - task Define function which convert decimal number into coresponding binary number. Binary numbers should be stored as a list for example: ghci> tobin 43 [0,1,0,1,0,1,1] --result ghci> tobin 13 [0,1,1,0,1] --result ghci> tobin [0,1,1,1,1,1,0,1,1,0,1,0,0,0,0,1,1] --result ghci> tobin 32 [0,1,0,0,0,0,0] --result ghci> tobin 127 [0,1,1,1,1,1,1,1] --result show Decimal to Binary solution Martin Perešíni Haskell Revision and Exercises April 10, / 53

42 Exercises Complex numbers Complex numbers - task Define new data type, complex number, and some basic operations like addition and multiplication of complex numbers. -- complex number consist of real and imaginary part ghci> Complx 4 6 Complx result ghci> Complx 1 (-6) Complx 1 (-6) --result ghci> Complx Complx 2 5 * Complx 1 4 Complx (-15) 18 --result ghci> Complx (-30) 5 + Complx 2 5 * Complx 1 4 Complx (-48) 18 --result ghci> Complx Complx 2 5 * Complx 1 (-4) Complx result show Complex numbers solution Martin Perešíni Haskell Revision and Exercises April 10, / 53

43 Exercises Sierpinski triangle Sierpinski triangle - task Define function which draw ASCII Sierpinski triangle of order N. Sierpinski triangle he Sierpinski triangle is a fractal and attractive fixed set with the overall shape of an equilateral triangle, subdivided recursively into smaller equilateral triangles. show Sierpinski triangle solution Martin Perešíni Haskell Revision and Exercises April 10, / 53

44 Exercises Permutations Permutations - task Write a program that generates all permutations of n different objects (input as a list). ghci> permutations' "abc" ["abc","acb","bac","bca","cab","cba"] --result ghci> permutations' [1,2,4] [[1,2,4],[1,4,2],[2,1,4],[2,4,1],[4,1,2],[4,2,1]] --result show Permutations solution Martin Perešíni Haskell Revision and Exercises April 10, / 53

45 Solutions Solutions Martin Perešíni Haskell Revision and Exercises April 10, / 53

46 Solutions XOR operation XOR operation - solution xor :: Bool -> Bool -> Bool xor x y x == True && y == False = True x == False && y == True = True otherwise = False xor' :: Bool -> Bool -> Bool xor' True False = True xor' False True = True xor' = False xor'' :: Bool -> Bool -> Bool xor'' True a = not a xor'' False a = a xor''' :: Bool -> Bool -> Bool xor''' True False = True xor''' False True = True xor''' = False show XOR task Martin Perešíni Haskell Revision and Exercises April 10, / 53

47 Solutions Spiral matrix Spiral matrix - solution import Data.List -- because of transpose spiral :: [[a]] -> [a] spiral [] = [] spiral (x:xs) = x ++ spiral (transpose $ map reverse xs) main :: IO () main = do print $ spiral [[1..3],[4..6],[7..9]] --wanted matrix -- matrix by each row, we can change this matrix show Spiral matrix task Martin Perešíni Haskell Revision and Exercises April 10, / 53

48 Solutions Find sublist in list Find sublist in list - solution findlist :: Eq a => [a] -> [a] -> Maybe Int findlist l1 l2 = findlisthelper l1 l2 0 findlisthelper :: Eq a => [a] -> [a] -> Int -> Maybe Int findlisthelper [] = Just 0 findlisthelper _ [] _ = Nothing findlisthelper l1 l2 index = if l1 == take (length l1) l2 then Just index else findlisthelper l1 (tail l2) (index + 1) show find sublist in list task Martin Perešíni Haskell Revision and Exercises April 10, / 53

49 Solutions Decimal to Binary Decimal to Binary - solution tobin 0 = [0] tobin n n `mod` 2 == 1 = tobin (n `div` 2) ++ [1] n `mod` 2 == 0 = tobin (n `div` 2) ++ [0] show Decimal to Binary task Martin Perešíni Haskell Revision and Exercises April 10, / 53

50 Solutions Complex numbers Complex numbers - solution -- define how our new type will look data Complx a = Complx a a deriving (Eq, Show) -- we derive from Eq and Show -- define operations for our new type instance Num a => Num (Complx a) where -- plus of two complex numbers (Complx r1 i1) + (Complx r2 i2) = Complx (r1+r2) (i1+i2) -- multiplication of two complex numbers (Complx r1 i1) * (Complx r2 i2) = Complx (r1*r2-i1*i2) (i1*r2+r1*i2) implement other for full new data type like abs, -- signum, frominteger, negate, etc. show Complex numbers task Martin Perešíni Haskell Revision and Exercises April 10, / 53

51 Solutions Sierpinski triangle Sierpinski triangle - solution sierpinski 0 = ["*"] sierpinski n = map ((space ++). (++ space)) down ++ map (unwords. replicate 2) down where down = sierpinski (n - 1) space = replicate (2 ^ (n - 1)) ' ' draw_siep n = mapm_ putstrln $ sierpinski n show Sierpinski triangle task Martin Perešíni Haskell Revision and Exercises April 10, / 53

52 Solutions Permutations Permutations - solution selections :: [a] -> [(a,[a])] selections [] = [] selections (x:xs) = (x,xs) : [(y,x:ys) (y,ys) <- selections xs] permutations' :: [a] -> [[a]] permutations' xs = [y:zs (y,ys) <- selections xs, zs <- permutations ys] show Permutations task Martin Perešíni Haskell Revision and Exercises April 10, / 53

53 Questions? Questions? Martin Perešíni Haskell Revision and Exercises April 10, / 53