✎ pp:l02 [books]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Pattern matching and basic types in Haskell ======

21. Extract the fourth element from a list of integers:

f l = head (tail (tail (tail l))))

22. Write the same function which returns 0 if the list contains less that four elements.

f [] = 0
f [_] = 0
f [_,_] = 0
f [_,_,_] = 0
f l = head (tail (tail (tail l))))

23. In Haskell, one can use patterns to examine the contents of lists, pairs and other dataypes.

f (x:y:z:w:l) = w
f _ = 0

   What types have x,y,z,w ? What type does have l ?

What about:

f (x:y:z:w:l) = w

   What is the difference?
    
24. Write a function which filters out all negative numbers:

f [] = []
f (x:xs) = 
	| x > 0 = x:(f xs)
	| otherwise = f xs

25. What is the type of the function:

f x y = (x,y)

[[discussion on pairs]] f :: a -> b -> (a,b)

26. What is the type of the function:

f 'a' _ = []
f x y = x:y

[[discussion on strings]] f :: Char -> String -> String


27. Let f "321CB" [("321CB", ["Matei", "Andrei", "Mihai"]), ("322CB",["George, Matei"])]
  = ["Matei", "Mihai"]

What is the signature of f?
 f :: String -> [(String,[String])] -> [String]

What does f do?

Write an implementation for f:

f x [] = []
f x ((y,l):ys)  
  | x == y = getM l
  | otherwise = f x ys
    where
        getM [] = []
        getM ((x:l):xs) 
          | x == 'M' = (x:l):(getM xs)
          | otherwise = getM xs

28. Write a function which returns true if the third largest element from a list is positive

f l = g (reverse (sort l))
	where g (x:y:z:_) =
				| z > 0 = True
				| otherwise = False
		  g _ = False

29. Sometimes it really helps to define function via function composition. For instance:

f x = (g.h) x
	where g x = 2*x
	      h x = x + 1

What type does f have?
What type does g have?

What does the following function do?

f x = ff x
	where g x = 2*x
	      h x = x + 1
	      ff = f.h

What does the following function do?

f x = ff x
	where g x = 2*x
	      h x = x + 1
	      ff = h.f



30. Rewrite exercise 28 via function composition:

f l = (g . reverse . sort) l
      where ...


31.(hard) Write a function which takes a list of pairs - student-name and grade, removes
    those with grades <5, splits the name in substrings, and adds one point bonus to
    people with three names:

    f [("Dan Matei Popovici",9),("Mihai",4),("Andrei Alex",6)] =
    	[(["Dan", "Matei", "Popovici"],10),(["Andrei,Alex"],6)]

f l = (bonus . splall . rem) l
	where rem [] = []
		  rem ((s,x):xs) 
		  	| x < 5 = rem xs
		  	| otherwise = (s,x):(rem xs)
 		  spl [] [] rest = rest
 		  spl [] w rest = w:rest
 		  spl (x:xs) w rest 
 		  		| x == ' ' = spl xs [] (w:rest)
 		  		| otherwise = spl xs (x:w) rest 
		  splall [] = []
 		  splall ((s,x):xs) = ((spl s),x):(splall xs)
 		  bonus [] = []
 		  bonus ((l,x):xs)
 		  		| (length l) == 3 = (l,x+1):(bonus xs)
 		  		| otherwise = (l,x):(bonus xs)

32. Write the signature and implement the following function:
   
   f ["Matei", "Mihai"] ["Popovici"] ["Dumitru"] = [("Matei","Popovici"), ("Mihai","Dumitru")]

   f :: [String] -> [String] -> [(String,String)]
   f (x:xs) (y:ys) = (x,y):(f xs ys)

33. Implement the following function:

   f ["Matei", "Mihai"] ["Popovici"] ["Dumitru"] = ["MPopovici", "MDumitru"]

   f (((c:_):xs)) (y:ys) = (c:y):(f xs ys)

34. Sometimes it helps to use functions in infix form. For instance:

	instead of mod x 2, we can write x `mode` 2. We can also define functions infix:

	x `f` y = x + y

	Implement an abbreviation function for exercise 31 and use it infix:

	f (x:ys) (y:ys) = (x `conc` y):(f xs ys)
		where (x:_) `conc` s = x:s

35. Just in the same way, we can treat infix functions as prefix. 
		:t (+)
		:t (&&)
		:t (++)

36. What about function composition? Is it a special operator, or is it just a function as well?
		
		:t (.)

37. What does the function below do?

f l = (((++) "?").((:) '>')) l


How about?

f = (((:) '>').(++"?"))

38. Write a function of a single line, such that:

f "Matei" = "[Matei]"

f = ("["++).(++"]")

39. Use only (:) to solve exercise 38 

f = ((:) '[') . reverse . ((:) ']') . reverse

40. What does the function ($) to? 
    (Use :t, and make up some tests)

41. Write the following implementation using only ($):

f "||" "Matei" = "||Matei||"

f s l = (s++) $ h $ (++s) $ reverse l


42.  Solve exercise 13. from [[Lab 2 | pp:l02]] using $ and other improvements (treat the case when the list has
     fewer elements):

   f l = g $ reverse l
   		where g (_:_:x:_) = not $ x `mod` 2 
   			  g _ = False