module L4B where import Test.QuickCheck import Data.List import Data.Char(isSpace) -- Higher-Order Functions -- dave 2017-09-21 ------------------------------------------ -- Taking similar definitions and -- making a function for the common -- programming pattern: data Card = Card {rank :: Rank, suit :: Suit} data Rank = Numeric Int | Jack -- etc data Suit = Hearts | Diamonds | Clubs | Spades deriving (Eq,Show) type Hand = [Card] countClubs :: Hand -> Int countClubs [] = 0 countClubs (c:cs) | suit c == Clubs = 1 + countClubs cs | otherwise = countClubs cs countSpades :: Hand -> Int countSpades h = count Spades h count :: Suit -> Hand -> Int count s [] = 0 count s (c:cs) | suit c == s = 1 + count s cs | otherwise = count s cs -- ** The most basic HOFs ** -- 1. map and filter examples, (Kahoot) -- ** Why do we need/want HOFs? ** -- . A common programming pattern: -- combining elements of a list -- (e.g. sum, product, and, or) {- sum' [] = 0 sum' (n:ns) = n + sum' ns -} prod [] = 1 prod (n:ns) = n * prod ns concat' [] = [] concat' (xs:xss) = xs ++ concat' xss foldr' f b [] = b foldr' f b (x:xs) = f x (foldr' f b xs) -- Foldr op b (a:b:c:...) == a `op` (b `op` (... `op` b)...) -- foldl op z (a:b:c:...) == ((base `op` a) `op` b) ...) song2 :: String song2 = unlines [ "I got my head checked" , "By a jumbo jet" , "It wasn't easy" , "But nothing is" , "No" ] -- Example use of foldr: unlines (c.f. lines) unlines' s = foldr joinLines "" s where joinLines s1 s2 = s1 ++ "\n" ++ s2 -- Example: takeLine, takeWord takeLine [] = [] takeLine (c:cs) | c /= '\n' = c:takeLine cs | otherwise = [] takeWord s = takeWhile (not . isSpace) s -- eta conversion -- takeWhile (\c -> not(isSpace c)) s -- where nonSpace c = not(isSpace c) takeWhile' p [] = [] takeWhile' p (c:cs) | p c = c:takeWhile' p cs | otherwise = [] -- f . g = \x -> f(g x) -- generalisation: takeWhile -- Defining takeLine using takeWhile, illustrating -- (i) anonymous functions (also known as lambda expressions) -- (ii) sections [slide] -- (iii) function composition ------------------------------------- -- More ways to build functions: Partial application -- A not very useful function: rep :: Int -> (String -> (Char -> String)) rep n s c = concat (replicate n (s++[c])) repfyr :: String -> Char -> String repfyr = rep 4 fyrfallig :: Char -> String fyrfallig = repfyr "hurra" -- redundant brackets in the type help explain partial application: -- Eta reduction -- use hlint to find this kind of thing (C-c C-v) -- Aside: -- Fixity. How do you know when to skip brackets? -- \$ -- zip -- numberLines :: String -> String -- number the lines in a text -- Example Design [Slides?] -- Function composition -- [Slides roundup] -- [Skip] Test.QuickCheck.Functions for testing HOFs (Fun _ f) --