Differences

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

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
pp:2023:haskell:l07 [2023/04/19 23:58]
tpruteanu [Lists] 		pp:2023:haskell:l07 [2023/04/27 01:17] (current)
mihai.udubasa [Lambda calculus as a programming language (optional)] fix typo
Line 69: Line 69:
 **A:** We can evaluate any of them, and it is guaranteed by [[https://​en.wikipedia.org/​wiki/​Church%E2%80%93Rosser_theorem | Church-Rosser theorem]] that if the expression is reducible, we will eventually get the same $ \beta $**-normal form**. **A:** We can evaluate any of them, and it is guaranteed by [[https://​en.wikipedia.org/​wiki/​Church%E2%80%93Rosser_theorem | Church-Rosser theorem]] that if the expression is reducible, we will eventually get the same $ \beta $**-normal form**.
  
-To not just randomly choose **redexes**,​ there exist // reduction strategies //, from which we will use the **Normal Order** and **Applicative Order**: \\+To not just randomly choose **redexes**,​ there exist //reduction strategies//,​ from which we will use the **Normal Order** and **Applicative Order**: \\
   * **Normal Order** evaluation consist of always reducing the //​leftmost//,​ //​outermost//​ **redex** (whenever possible, subsitute the arguments into the function body) \\   * **Normal Order** evaluation consist of always reducing the //​leftmost//,​ //​outermost//​ **redex** (whenever possible, subsitute the arguments into the function body) \\
   * **Applicative Order** evaluation consist of always reducing the //​leftmost//,​ //​innermost//​ **redex** (always reduce the function argument before the function itself) \\   * **Applicative Order** evaluation consist of always reducing the //​leftmost//,​ //​innermost//​ **redex** (always reduce the function argument before the function itself) \\
Line 86: Line 86:
  
 The [[https://​en.wikipedia.org/​wiki/​Church%E2%80%93Turing_thesis | Church-Turing thesis]] asserts that any //​computable//​ function can be computed using lambda calculus (or Turing Machines or equivalent models). \\ The [[https://​en.wikipedia.org/​wiki/​Church%E2%80%93Turing_thesis | Church-Turing thesis]] asserts that any //​computable//​ function can be computed using lambda calculus (or Turing Machines or equivalent models). \\
-For the curios, a series of additional exercises covering this topic can be found here: [[pp:​2023:​haskell:​l07-extra|Lambda Calculus as a programming language]]. \\+For the curious, a series of additional exercises covering this topic can be found here: [[pp:​2023:​haskell:​l07-extra|Lambda Calculus as a programming language]]. \\
  
 ===== 7.2 Intro to Haskell ===== ===== 7.2 Intro to Haskell =====
Line 101: Line 101:
 Remember: [[pp:​2023:​scala:​l01|Lab 1. Introduction to Scala]] Remember: [[pp:​2023:​scala:​l01|Lab 1. Introduction to Scala]]
  
-**7.2.1.** Implement a tail-recursive function that computes the factorial of a natural number. ​Start from the code stub below:+**7.2.1.** Implement a tail-recursive function that computes the factorial of a natural number.
 <code haskell> <code haskell>
 fact :: Int -> Int fact :: Int -> Int
 fact = undefined fact = undefined
 </​code>​ </​code>​
-**7.2.2.** Implement a tail-recursive function that computes the greatest common divisor of two natural numbers:+**7.2.2.** Implement a tail-recursive function that computes the greatest common divisor of two natural numbers.
 <code haskell> <code haskell>
-gcd :: Int -> Int -> Int +mygcd :: Int -> Int -> Int 
-gcd a b = undefined+mygcd a b = undefined
 </​code>​ </​code>​
 **7.2.3.** Implement the function ''​mySqrt'' ​ which computes the square root of an integer $ a $. **7.2.3.** Implement the function ''​mySqrt'' ​ which computes the square root of an integer $ a $.
Line 122: Line 122:
 } }
 </​code>​|<​code haskell> ​ </​code>​|<​code haskell> ​
-f l = case l of {+f l = case l of
   [] -> ...   [] -> ...
-  (x:​xs) ​=> ... +  (x:​xs) ​-> ...
-}+
 </​code>​ | <code haskell> </​code>​ | <code haskell>
 f [] = ... f [] = ...
Line 134: Line 133:
 </​code>​ | </​code>​ |
  
-**7.2.4.** Implement funtions ''​minimum''​ and ''​maximum''​ that take a list of ints, and return the smallest/​biggest value in the list.+**7.2.4.** Implement funtions ''​mymin''​ and ''​mymax''​ that take a list of ints, and return the smallest/​biggest value in the list.
  
 **7.2.5.** Implement a function ''​unique''​ that takes a list of ints, and removes all duplicates. **7.2.5.** Implement a function ''​unique''​ that takes a list of ints, and removes all duplicates.
Line 144: Line 143:
   * a string representation of the number otherwise   * a string representation of the number otherwise
  
-**7.2.7.** Extend the function from **7.2.5.** with the following rules:+**7.2.7.** Extend the function from **7.2.6.** with the following rules:
   * **'​Bazz'​** if the number is divisible by 7   * **'​Bazz'​** if the number is divisible by 7
   * **'​FizzBazz'​** if the number is divisible by 21   * **'​FizzBazz'​** if the number is divisible by 21
Line 199: Line 198:
 </​note>​ </​note>​
  
-==== Brain Twisters ====+===== 7.3 Brain Twisters ​=====
  
-Implement ''​map''​ using ''​foldl''​ and ''​foldr''​.+**7.3.1.** ​Implement ''​map''​ using ''​foldl''​ and ''​foldr''​.
 <code haskell> <code haskell>
 mymapl :: (a -> b) -> [a] -> [b] mymapl :: (a -> b) -> [a] -> [b]
Line 207: Line 206:
 </​code>​ </​code>​
  
-Implement ''​filter''​ using ''​foldl''​ and ''​foldr''​.+**7.3.2.** ​Implement ''​filter''​ using ''​foldl''​ and ''​foldr''​.
 <code haskell> <code haskell>
 myfilterl :: (a -> Bool) -> [a] -> [a] myfilterl :: (a -> Bool) -> [a] -> [a]
Line 213: Line 212:
 </​code>​ </​code>​
  
-Implement ''​foldl''​ using ''​foldr''​.+**7.3.3.** ​Implement ''​foldl''​ using ''​foldr''​.
 <code haskell> <code haskell>
 myfoldl :: (a -> b -> a) -> a -> [b] -> a myfoldl :: (a -> b -> a) -> a -> [b] -> a
 </​code>​ </​code>​
  
-Implement ''​bubbleSort''​.+**7.3.4.** ​Implement ''​bubbleSort''​.
 <code haskell> <code haskell>
 bubbleSort :: [Int] -> [Int] bubbleSort :: [Int] -> [Int]
 </​code>​ </​code>​
  
-Implement ''​quickSort''​.+**7.3.5.** ​Implement ''​quickSort''​.
 <code haskell> <code haskell>
 quickSort :: [Int] -> [Int] quickSort :: [Int] -> [Int]
 </​code>​ </​code>​