2. (18 points) Suppose that the following definitions are made (same as in Question 1):

Transcription

1 1. (18 points) Suppose that the following definitions are made: import Data.Char data Roadway = Avenue Char Lane [Integer] String Parkway Float Int doze :: Integer -> Bool doze m = even m m > 10 dream :: (Integer -> Bool) -> [Integer] -> Float dream h (d:ds) h d = 4.0 otherwise = dream h ds dream h [] = travel :: Roadway -> Int travel (Parkway y z) = z travel (Lane (d:e:rest) ms) = length (rest) + travel (Avenue W ) travel _ = 70 Give the values of the following expressions. (a) (\ m -> 10-m) 2 8 (b) [6,8..13] [6,8,10,12] (c) [ [k+20] k <- [1..4] ] [[21], [22], [23], [24]] (d) unzip [(9,8),(7,6),(2,1)] ([9,7,2], [8,6,1]) (e) concatmap (\ w -> [w,w]) [6,3,7] [6,6,3,3,7,7] (f) dropwhile even [6,2,3,7,8,1,5] [3,7,8,1,5] (g) dream doze [3,7,4,1] (h) travel (Parkway ) 18 (i) travel (Lane [4,3,8,5] "auto") (18 points) Suppose that the following definitions are made (same as in Question 1):

2 import Data.Char data Roadway = Avenue Char Lane [Integer] String Parkway Float Int doze :: Integer -> Bool doze m = even m m > 10 dream :: (Integer -> Bool) -> [Integer] -> Float dream h (d:ds) h d = 4.0 otherwise = dream h ds dream h [] = travel :: Roadway -> Int travel (Parkway y z) = z travel (Lane (d:e:rest) ms) = length (rest) + travel (Avenue W ) travel _ = 70 Give the types of the following expressions. (a) dream doze [] Float (b) (\ p m -> m:"way") a -> Char -> String (c) map travel [Roadway] -> [Int] (d) [toupper, tolower, tolower] [Char -> Char] (e) snd (dream, islower) Char -> Bool (f) filter doze [] [Integer] (g) Lane [Integer] -> String -> Roadway (h) uncurry (:) (a,[a]) -> [a] (i) zip [False,True] [b] -> [(Bool,b)] 3. (12 points) For each of the following, fill in the blank with a pattern that gives the function the indicated behavior.

3 (a) uno "mac" should return "ac" and uno [2,6,1,8] should return [6,1,8]: (_:a) uno = a (b) dos (3, e,7) should return 1, and dos (8, r,false) should return 6: (b,_,_) dos = b-2 (c) tres [6,4,2,3,5] should return [3,4] and tres "spring" should return "ip": (_:d:_:c:_) tres = [c,d] (d) cuatro [(10,20),(30,40)] should return 30, and cuatro [(5,6),(7,8),(9,0)] should return 7: (_:(e,_):_) cuatro = e 4. (6 points) Consider the following Haskell function: banter :: Int -> [(Int,Char)] -> [Bool] banter k ws = [ even (p+k) (p,s) <- ws, isupper s ] Fill in the blanks below to write an equivalent function using map and filter: (\ (p,s) -> even (p+k)) (\ (p,s) -> isupper s) banter k ws = map (filter ws) 5. (34 points) A small taco shop offers a very limited menu: Drinks are available in two sizes: large (for $2.75 each) and small (for $2.00 each). Nachos cost $8.95. There are three styles of tacos: chicken tacos, tofu tacos, and beef tacos. The chicken tacos costs $12.00 apiece; all other tacos cost $10.25 each. There are four toppings that can be added to tacos in any combination and any amount: lettuce, salsa, onions, and cheese. Each topping adds $0.50 to the cost of a taco, so (for example) adding two units of salsa and one unit of cheese increases a taco s cost by $1.50.

4 These menu options can be represented with the following Haskell types (note that none of the types belong to the Eq class, so you cannot use == or /= on values of these types): data Style = Chicken Tofu Beef data Topping = Lettuce Salsa Onions Cheese data Size = Small Large data MenuItem = Drink Size Nachos Taco Style [Topping] (a) (15 points) Write a Haskell function price:: MenuItem -> Float such that price item calculates the price (in dollars) of item. For example: *Main> price (Drink Large) 2.75 *Main> price (Taco Chicken []) 12.0 *Main> price (Taco Beef [Lettuce, Onions, Lettuce, Cheese]) price Nachos = 8.95 price (Drink Large) = 2.75 price (Drink Small) = 2.00 price (Taco Chicken ts) = sum [ 0.5 _ <- ts] price (Taco _ ts) = sum [ 0.5 _ <- ts] price Nachos = 8.95 price (Drink Large) = 2.75 price (Drink Small) = 2.00 price (Taco st ts) = cost st + sum [ 0.5 _ <- ts] cost :: Style -> Float cost Chicken = cost _ = (b) (12 points) Write a Haskell function supersize :: MenuItem -> MenuItem

5 such that supersize item returns a menu item that is similar to item except that (i) small orders are replaced by large orders and (ii) all cheese is doubled. For example: *Main> supersize Nachos Nachos *Main> supersize (Drink Small) Drink Large *Main> supersize (Taco Tofu [Lettuce,Cheese,Salsa,Onions,Cheese]) Taco Tofu [Lettuce,Cheese,Cheese,Salsa,Onions,Cheese,Cheese] supersize (Drink _) = Drink Large supersize Nachos = Nachos supersize (Taco style ts) = Taco style (helper ts) helper :: [Filling] -> [Filling] helper [] = [] helper (Cheese:rest) = Cheese: Cheese: helper rest helper (item:rest) = item : helper rest supersize (Drink _) = Drink Large supersize Nachos = Nachos supersize (Taco style ts) = Taco style (concatmap help ts) help :: Topping -> [Topping] help Cheese = [Cheese, Cheese] help t = [t] (c) (7 points) Write a Haskell function withonions :: [MenuItem] -> Int such that withonions items computes the number of tacos in items that contain Onions. For example: *Main> withonions [Taco Beef [Onions, Salsa, Onions], Taco Tofu []] 1 *Main> withonions [Drink Small, Nachos, Taco Beef [Cheese]] 0 withonions items = sum [ 1 Taco _ ts <- items, not (null [ 1 Onions <- ts])] withonions items = sum [ 1 Taco _ ts <- items, hasonions :: [Filling] -> Bool hasonions [] = False hasonions ts]

6 hasonions (Onions:_) = True hasonions (_:rest) = hasonions rest 6. (12 points) Write a Haskell function map2 :: (a -> b -> c) -> [a] -> [b] -> [c] such that map2 behaves just like Haskell s built-in function zipwith. That is, map2 f xs ys returns a list exactly as long as the shorter of xs and ys: the i th value of that list is obtained by applying f to the i th values of xs and ys (respectively). Do not use zipwith in your answer. For example: *Main> map2 (+) [1,2,3,4] [50,60,70] [51,62,73] *Main> map2 (:) [1,2] [[3,4,5], [6], [7,8]] [[1,3,4,5], [2,6]] map2 f (x:xs) (y:ys) = f x y : map2 f xs ys map2 _ = [] map2 f xs ys = map (uncurry f) (zip xs ys)