Differences

This shows you the differences between two versions of the page.

--- pp:l03 [2020/03/13 16:53]
pdmatei
+++ pp:l03 [2022/03/20 15:13] (current)
bogdan.deac
@@ Line 1: / Line 1: @@
-====== Higher-order functions ======
+====== 3. Higher-order functions ======
 ==== Function application and composition as higher-order functions ====
 One key idea from functional programming is that functions are **first-class** (or **first-order**) values, just like integers, strings, etc. . They can be passed as function **arguments** and also be returned by function application.
-Functions which //take other functions as parameter// are called **higher-order**. We have already encountered two such functions, i.e. ''($)'' and ''(.)''.
+Functions which //take other functions as parameter// are called **higher-order**.
-. Define the operator ''($)'' from [[pp:l02|Lab 2]] as a higher-order function.
+==== Lambdas ====
+Functions can be passed as arguments just like any other value value. Also, functions can be returned as parameter. In order to do so, it is convenient to define functions without naming them. This is done using **lambda**'s. For a more detailed discussion regarding lambdas, see the lecture. The following definitions are equivalent:
-. What type should functional composition have?
-. Define function composition.
-. Functions can be passed as arguments just like any other value value. Also, functions can be returned as parameter. In order to do so, it is convenient to define functions without naming them. This is than using **lambda**'s. For a more detailed discussion regarding lambdas, see the lecture. The following definitions are equivalent:
 <code haskell>
 f x y = x + y
@@ Line 20: / Line 16: @@
 </code>
-That is the type of f?
+===== 3.1. String processing =====
-What is the type of f 5?
+The following is an input test. You can add more examples to it:
+<code haskell>
+l = ["matei@gmail.com", "mihai@gmail.com", "tEst@mail.com", "email@email.com", "short@ax.ro"]
+</code>
-. Consider sets represented as characteristic functions with signature
+Use ''map'', ''foldr''/''foldl'', instead of recursive functions. Wherever possible, use functional composition and closures.
-     s :: Integer -> Bool
-     s x is true if x is in the set.
+.1.1. Remove uppercases from emails. (Do **not** use recursion). To be able to use character functions from the library, add ''import Data.Char'' at the beginning of the program. Use the Internet to find the appropriate character function.
-    Write a membership function
+<code haskell>
+-- write this function as a closure
+rem_upper =
+</code>
-   mem s x = s x
+.1.2. Write a function which removes emails longer than a given size. Write the function as a **functional closure**. Use anonymous functions in your implementation, then think about how you can replace them by a functional composition of more basic functions. **Hint:** Write your code in steps. Start with the basic idea, then think about how you can write it better and cleaner.
-   or
+<code haskell>
+longer :: Int -> [String] -> [String]
+longer x =
+</code>
-   mem = ($)
+.1.3. Count the number of emails longer than 12 characters. Use a fold, anonymous functions and functional composition.
+<code haskell>
+howmany =
+</code>
-. Write the set {1,2,3}
+.1.4. Split the list between first names and email domains. What ingredients (auxiliary functions) are necessary? Use either a fold or a tail-recursive function in your implementation.
-   f 1 = True
+<code haskell>
-   f 2 = True
+names_emails :: [String] -> [[String]]
-   f 3 = True
+names_emails =
-   f _ = False
+</code>
-. Write the set of natural numbers
+.1.5. Identify the list of the employed domain names (e.g. ''gmail.com''). Remove duplicates. Use no recursion and no additional prelude function apart from ''head'' and ''tail''. **Hint** think about the sequence of basic operations you want to perform and assemble them using functional composition.
+<code haskell>
+domains :: [String] -> [String]
+domains =
+</code>
-   f x = x > -1
+(!) 3.1.6. In some previous exercise you have, most likely, implemented a split function using ''foldr''. Implement one with ''foldl''. **Hint:** use an example together with the ''foldl'' implementation to figure out what the accumulator should do.
-. Implement the intersection of two sets:
+<code haskell>
+splitl :: String -> [String]
+splitl =
+</code>
-union f g = \x -> f x && g x
+.1.7. Write a function which extracts the domains from emails, without the dot part. (e.g. ''gmail''). Generalise the previous function ''splitl'' to ''splitBy:: Char -> String -> [String]'', and use it each time necessary, in your implementation. **Hint**: Wherever you want to mix pattern matching with guards, start with the patterns first.
-. Write reunion in another way
+<code haskell>
+domain :: [String] -> [String]
+domain =
+</code>
-union f g x = f x && g x
+===== 3.2. A predicate-based implementation for sets =====
+.2.1. Consider **sets** represented as characteristic functions with signature ''s :: Integer -> Bool'', where ''s x'' is true if ''x'' a member in the set. Examples:
+<code haskell>
+s1 1 = True
+s1 2 = True
+s1 _ = False
-. Write a function which takes a list of sets, and returns that set
+s2 x = mod x 2 == 0
-. (hard) Implement a function which takes a list of sets and computes their intersection
+s3 _ = False
-f [s] = s
+</code>
-f (s:xs) = \x -> s x && (f xs) x
+Above, ''s1'' is the set $math[\{1,2\}], ''s2'' is the set of even integers and ''s3'' is the empty-set. Write a function which tests if an element is a member of a set:
+<code haskell>
+mem :: (Integer -> Bool) -> Integer -> Bool
+mem = ...
+</code>
+.2.2. Define the set $math[\{2^n \mid n\in\mathbb{N}\}].
+.2.3. Define the set of natural numbers.
-. Write a function which receives a g :: Integer -> Bool, a list of integers,
+.2.4. Implement the intersection of two sets. Use lambdas.
-    and returns a list of integers for which g is true.
+<code haskell>
+intersection :: (Integer -> Bool) -> (Integer -> Bool) -> (Integer -> Bool)
+</code>
-filter p [] = []
+.2.5. Write intersection in another way, (without using lambdas).
-filter p (x:xs)
+<code haskell>
-	| p x == True = x:(filter p xs)
+intersection' :: (Integer -> Bool) -> (Integer -> Bool) -> Integer -> Bool
-	| otherwise = filter p xs
+</code>
-. Solve exercise 22. using filter
+.2.6. Write a function which takes a list of integers, and returns the set which contains them.
+<code haskell>
+toSet :: [Integer] -> (Integer -> Bool)
+</code>
-f = filter (>0)
+.2.7. Implement a function which takes a list of sets and computes their intersection.
-. Implement map
+<code haskell>
+capList :: [Integer -> Bool] -> Integer -> Bool
+</code>
-. Solve exercise 15. using map:
+===== 3.3. Brain twisters =====
+.3.1. Implement ''map'' using ''foldl'' and ''foldr''
-f = map g
+<code haskell>
-		where g True = 1
+mapr :: (a -> b) -> [a] -> [b]
-		      g False = 0
+mapl :: (a -> b) -> [a] -> [b]
+</code>
-. Solve exercise 25. using map and filter:
-Let f "321CB" [("321CB", ["Matei", "Andrei", "Mihai"]), ("322CB",["George, Matei"])]
-  = ["Matei", "Mihai"]
-  (Hint. Pattern matching can be used in lambdas. Use fst and snd on pairs)
-f x l = (filter (\(c:_)-> c == 'M')) $ snd $ head $ (filter (\(f,_)-> f==x)) l
-or
-f x = (filter (\(c:_)-> c == 'M')) . snd . head . (filter (\(f,_)-> f==x))
-. Solve exercise 29. using map and filter
-    f [("Dan Matei Popovici",9),("Mihai",4),("Andrei Alex",6)] =
-    	[(["Dan", "Matei", "Popovici"],10),(["Andrei,Alex"],6)]
-f = bonus . splall . rem
-	where
-		rem = filter (\(_,y) -> y > 4)
-		splall = map (\(x,y) -> (spl x,y))
-		bonus = map (\(l,y) -> if length l == 3 then (l,y+1) else (l,y))
-		spl [] [] rest = rest
- 		spl [] w rest = w:rest
- 		spl (x:xs) w rest
- 		  	| x == ' ' = spl xs [] (w:rest)
- 		  	| otherwise = spl xs (x:w) rest
-. Write a function which appends a list of lists:
-f [] = []
-f (x:xs) = x ++ (f xs)
-. Write the same function tail-recursively
-f [] acc = acc
-f (x:xs) acc = f xs (x++acc)
-Are the two functions identical? Why?
-. Implement foldr
-. Implement foldl
-. Implement concatenation using a fold:
-  app l1 l2 = foldr (:) l2 l1
-. Implement reversal using a fold:
-  rev = foldl (\x y->y:x) []
-.(hard) Implement the string-splitting function from exercise 46 using folds:
-    (Hint: thing about what the accumulator should hold)
-(Note for TA: signature needed. Discussion for later)
-spl :: String -> [String]
-spl = foldr op [""]
-        where op ' ' (l:rest) = []:l:rest
-              op c (l:rest) = (c:l):rest
-. Implement exercise 47 using fold:
-f (s:xs) = foldr (\s acc x-> s x && acc x) s xs
+.3.2. Implement ''filter'' using ''foldl'' and ''foldr''
+<code haskell>
+filterl :: (a -> Bool) -> [a] -> [a]
+filterr :: (a -> Bool) -> [a] -> [a]
+</code>
+.3.3. Implement ''foldl'' using ''foldr''
+<code haskell>
+myfoldl :: (a -> b -> a) -> a -> [b] -> a
+</code>
+.3.4. Implement ''bubbleSort''. It must use at least one fold
+ <code haskell>
+bubbleSort :: [Integer] -> [Integer]
+</code>