✎ pp:2024:scala: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.
====== Lab 2. High order functions ======

Objectives:
  * implement and use **higher-order** functions. A **higher-order** function takes other functions as parameter or returns them
  * implement **curry** and **uncurry** functions, and how they should be properly used (review lecture).

** Create a new Scala worksheet to write your solutions **

===== 2.1 Intro. Functions as parameters =====
**2.1.1** Write a function ''apply'' that takes an integer and return the result of the applied function on the given integer. Start from the code stub below:
<code scala>
def apply(n: Int, f: Int => Int): Int = {
   ???
}
</code>

**2.1.2** Write a function ''doubler'' that returns a function that doubles the input it receives (an integer). Start from the code stub below:
<code scala>
def doubler(): Int => Int = {
   ???
}
</code>

**2.1.3** Create a function ''trycatch'' that takes an integer as argument and evaluates its value using the try function. If an error occurs (try function returns 0), the catch function will be called instead.
<code scala>
def trycatch(t: Int => Int, c: Int => Int)(x: Int): Int = {
   ???
}
</code>

**2.1.4** Write a function ''realtrycatch'' where t and c take no parameters and produce a result upon evaluation. If an error occurs (try function returns 0), the catch function will be called instead.
<code scala>
def realtrycatch(t : => Int, c: => Int): Int  = {
   ???
}
</code>

===== 2.2 Custom high order functions =====
**2.2.1** Define the function ''foldWith'' which uses an operation ''op'' to reduce a range of integers to a value. For instance, given that ''op'' is addition (+), the result of folding the range 1 to 3 will be 1+2+3=6. ''foldWith'' should be curried (it will take the operation and return another function which expects the bounds).
<code scala>
def foldWith (op: (Int,Int) => Int)(start: Int, stop: Int): Int = {
  def tail_fold(crt: Int, acc: Int): Int  = ???
  ??
}
</code>

**2.2.2** Define the function ''foldConditional'' which extends ''foldWith'' by also adding a predicate ''p: Int => Int''. ''foldConditional'' will reduce only those elements of a range which satisfy the predicate.

<code scala>
def foldConditional(op: (Int,Int) => Int, p: Int => Boolean)(start: Int, stop: Int): Int = ???
</code>

**2.2.3** Write a function ''foldMap'' which takes values $math[a_1, a_2, \ldots, a_k] from a range and computes $math[f(a_1)\;op\;f(a_2)\;op\;\ldots f(a_k)].
Use the ''apply'' and ''foldWith'' methods
<code scala>
def foldMap(op: (Int,Int) => Int, f: Int => Int)(start: Int, stop: Int): Int = ???
</code>

===== 2.3 Curry vs Uncurry =====
**2.3.1** Modify the function below so that it's curry and use it to calculate ''5*3''
<code scala>
def multiply(x:Int, y:Int): Int => x * y
</code>

**2.3.2** Modify the function below so that it's curry and use it to compare 3 numbers and return the maximum
<code scala>
def compare(x: Int, y: Int, z: Int): Int =
{
  if x > y && x > z then 
    x
  else if y > x && y > z then
    y
  else
    z
}
</code>

===== 2.4 Function transformations =====
The graph of a function can undergo different geometric transformation such as scaling, shifting, rotating, mirroring and so on. The result of those transformation will also be a function that looks similarly to the original. In this exercice we will particularly work with lines. A line is a linear equation of the form $math[f(x) = a*x + b]

**2.4.1** Implement a function that shifts a line on Oy axis by a certain amount $math[\Delta y]
<code scala>
def shiftOY(line: Double => Double, delta_y: Double): Double => Double = {
   ???
}
</code>

**2.4.2** Implement a function that shifts a line on Ox axis by a certain amount $math[\Delta x]
<code scala>
def shiftOX(line: Double => Double, delta_x: Double): Double => Double = {
   ???
}
</code>

**2.4.3** Implement a function that checks if two lines intersect at an integer value from a given interval
<code scala>
def intersect(line1: Double => Double, line2: Double => Double)(start: Int, stop: Int): Boolean = {
   ???
}
</code>