Differences
This shows you the differences between two versions of the page.
| Both sides previous revision Previous revision Next revision | Previous revision | ||
|
pp:2025:scala:l02 [2025/03/10 21:17] ldaniel [2.3 Curry vs Uncurry] |
pp:2025:scala:l02 [2025/03/16 01:35] (current) cata_chiru |
||
|---|---|---|---|
| Line 59: | Line 59: | ||
| def foldMap(acc: Int)(op: (Int,Int) => Int, f: Int => Int)(start: Int, stop: Int): Int | def foldMap(acc: Int)(op: (Int,Int) => Int, f: Int => Int)(start: Int, stop: Int): Int | ||
| = ??? | = ??? | ||
| + | </code> | ||
| + | |||
| + | **2.2.5** Write a function ''sum'' which takes values start, end and computes the sum of numbers between start and end. | ||
| + | Use the curry function ''foldWith'' defined before. | ||
| + | <code scala> | ||
| + | def sum(start: Int, stop: Int): Int = ??? | ||
| </code> | </code> | ||
| Line 73: | Line 79: | ||
| if (x > y && x > z) x | if (x > y && x > z) x | ||
| else if (y > x && y > z) y | else if (y > x && y > z) y | ||
| - | el | + | else z |
| - | se z | + | |
| } | } | ||
| </code> | </code> | ||
| Line 101: | Line 106: | ||
| } | } | ||
| </code> | </code> | ||
| + | |||
| + | ===== 2.5 Nice to know ===== | ||
| + | |||
| + | In a computer, we would like the central processing unit / thread to have predominantly a managerial role. | ||
| + | |||
| + | As a result, by executing intense computation on this branch, we would delay other functionalities or would lock into a specific task instead of scheduling. | ||
| + | |||
| + | To solve this limitation, programmers have created ways ('''functional closures''') in which the main thread injects all the needed parameters to functions and then passes them to other threads, from where they can be unpacked and run. | ||
| + | |||
| + | Such an implementation for functional closures is represented by '''zero-parameter lambdas''' where the evaluation is delayed by currying such a function over our method: | ||
| + | |||
| + | <code scala> | ||
| + | // Variation 1 - using zero-parameter lambdas | ||
| + | // the type of the target function | ||
| + | type Result = Int | ||
| + | |||
| + | // a closure is represented as a function that takes zero parameters | ||
| + | type Closure = () => Result | ||
| + | |||
| + | // type of a demo function | ||
| + | type TFun = (Int, Int) => Result | ||
| + | |||
| + | // run in thread will call that function to evaluate | ||
| + | def run_in_thread(f: Closure): Result = f() | ||
| + | |||
| + | // Dummy method used to illustrate the power of currying | ||
| + | // "f" in curry_for_thread | ||
| + | def process_data(x: Int, y: Int): Int = { | ||
| + | println("Hello") | ||
| + | x + y | ||
| + | } | ||
| + | |||
| + | // creates a lambda with zero parameters, thus "delaying" the call of f | ||
| + | // "f" in run_in_thread | ||
| + | def curry_for_thread(f: TFun, somex: Int, somey: Int): Closure = | ||
| + | () => f(somex, somey) | ||
| + | |||
| + | val close = curry_for_thread(process_data, 0, 1) | ||
| + | |||
| + | // If you run this code into a Scala Worksheet you will see that "Hello" gets printed when calling the function bellow. | ||
| + | // This is thanks to the 0 parameter lambda in curry_for_thread that "forces" | ||
| + | // another call of the function for it to execute its body. | ||
| + | run_in_thread(close) | ||
| + | </code> | ||
| + | |||
| + | Keep this example in mind! We will meet with it again in a future laboratory! :-) | ||
| + | |||
| + | |||