Differences

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

--- pp:2025:scala:l02 [2025/03/10 21:37]
ldaniel
+++ pp:2025:scala:l02 [2025/03/16 01:35] (current)
cata_chiru
@@ Line 79: / Line 79: @@
   if (x > y && x > z) x
   else if (y > x && y > z) y
-  el
+  else z
-se z
 }
 </code>
@@ Line 107: / Line 106: @@
 }
 </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! :-)