Finish currying chapter

Author: matterche

src/main/worksheets/f_Functions/b_higher_order_functions_2_exercise.sc

@@ -12,3 +12,12 @@ val maxLiteral: Int => String => Boolean = maximum => s => s.length <= maximum
 
 acceptString("Foo", minLiteral(1))
 acceptString("Foo", maxLiteral(2))
+
+
+// Lost in parameter type lists? Type alias to the rescue!
+type Predicate = String => String => Boolean
+
+val is: Predicate = oneString => otherString => oneString == otherString
+
+acceptString("FooBar", is("FooBar"))
+

src/main/worksheets/f_Functions/c_partially_applied_2_use_case.sc

@@ -3,11 +3,11 @@
  */
 def acceptString(s: String, pred: String => Boolean): Boolean = pred(s)
 
-def min(minimum: Int): String => Boolean = (s: String) => s.length >= minimum
-def max(maximum: Int): String => Boolean = (s: String) => s.length <= maximum
+def min(minimum: Int): String => Boolean = s => s.length >= minimum
+def max(maximum: Int): String => Boolean = s => s.length <= maximum
 
 /**
- * A function which applies a list of predicates to a string.
+ * A function which returns a function which applies a list of predicates to a string.
  */
 def any(predicates: (String => Boolean)*): String => Boolean =
   s => predicates.forall(pred => pred(s))

src/main/worksheets/f_Functions/currying_4_enables_syntactic_sugar.sc

@@ -14,6 +14,9 @@ def acceptString(s: String, pred: String => Boolean): Boolean = pred(s)
 acceptString("Hello World", seq => seq.length > 1)
 acceptString("Hello World", seq => seq.length < 100)
 
+/**
+ * Enables definition of functions which look more like built-in language constructs
+ */
 def acceptStringCurried(s: String)(pred: String => Boolean): Boolean = pred(s)
 
 acceptStringCurried("Hello World") {
@@ -22,4 +25,5 @@ acceptStringCurried("Hello World") {
 
 acceptStringCurried("Hello World") {
   seq => seq.length < 100
-}
+}
+

src/main/worksheets/f_Functions/currying_9_all.sc

@@ -0,0 +1,24 @@
+/**
+ * Curried functions enable compiler for type inference
+ */
+def acceptCurried[T](something: T)(pred: T => Boolean): Boolean = pred(something)
+
+
+// types in predicate function can be omitted
+acceptCurried("Curry")(s => s.length > 0)
+acceptCurried("Curry")(_.length > 0)
+acceptCurried(15)(i => i > 0)
+acceptCurried(15)(_ > 0)
+
+
+// Type inference is not possible in uncurried version
+def accept[T](s: T, pred: T => Boolean): Boolean = pred(s)
+
+accept("Curry", (s: String) => s.length > 0)
+accept(15, (i: Int) => i > 0)
+
+// without currying this is not possible:
+//accept("Curry", s => s.length > 0)
+//accept("Curry", _.length > 0)
+//accept(15)(i => i > 0)
+//accept(15)(_ > 0)

src/main/worksheets/f_Functions/currying_1_intro.sc renamed to src/main/worksheets/f_Functions/d_currying_1_intro.sc

@@ -0,0 +1,13 @@
+/**
+ * Currying must be used when working with implicit parameter lists.
+ *
+ * Implicit parameter lists are frequently used to inject dependencies into functions.
+ */
+def accept(s: String)(implicit pred: String => Boolean): Boolean = pred(s)
+
+implicit val isOink: String => Boolean = s => s == "Oink"
+
+accept("Yeeha")
+accept("Oink")
+
+// Show Example code from Play framework project with implicit request

src/main/worksheets/f_Functions/d_currying_2_enables_type_inference_syntactic_sugar.sc

@@ -3,7 +3,12 @@ import java.util.Scanner
 
 import scala.util.Try
 
-// loan pattern - loan a resource to a function
+
+/**
+ * Loan pattern: Loan a resource to a function
+ *
+ * Here without currying
+ */
 def withFile[T](f: File, handler: Scanner => T): Option[T] = {
   val scanner = Try(new Scanner(f))
   try {
@@ -18,5 +23,5 @@ def withFile[T](f: File, handler: Scanner => T): Option[T] = {
   }
 }
 
-withFile(new File("idea.properties"), scanner =>
+val properties = withFile(new File("idea.properties"), scanner =>
   scanner.useDelimiter("\\Z").next())

src/main/worksheets/f_Functions/d_currying_3_implicit_parameter_lists.sc

@@ -7,8 +7,12 @@ import scala.util.Try
 // or a by name parameter. This has two advantages. First, the function argument
 // can then look like a code block enclosed in braces. E.g.
 
-
-def withFileCurried[T](f: File)(handler: Scanner => T): Option[T] = {
+/**
+ * Loan pattern: Loan a resource to a function
+ *
+ * Here with currying
+ */
+def withFile[T](f: File)(handler: Scanner => T): Option[T] = {
   val scanner = Try(new Scanner(f))
   try {
     scanner.map(scanner =>
@@ -22,7 +26,6 @@ def withFileCurried[T](f: File)(handler: Scanner => T): Option[T] = {
   }
 }
 
-// curried version of a function looks like built in control structure
-withFileCurried(new File("idea.properties")) { scanner =>
+val properties = withFile(new File("idea.properties")) { scanner =>
   scanner.useDelimiter("\\Z").next()
 }

src/main/worksheets/f_Functions/currying_2_loan_pattern.sc renamed to src/main/worksheets/f_Functions/d_currying_99_bonus_loan_pattern.sc

@@ -0,0 +1,67 @@
+/**
+ * "Currying is the technique of translating the evaluation of a function that takes
+ * multiple arguments (or a tuple of arguments) into evaluating a sequence of functions,
+ * each with a single argument (partial application)"
+ *
+ * https://en.wikipedia.org/wiki/Currying
+ */
+
+def sum(x: Int, y: Int) = x + y
+def sumCurried(x: Int)(y: Int) = x + y
+
+def acceptString(s: String, pred: String => Boolean): Boolean = pred(s)
+
+acceptString("Hello World", seq => seq.length > 1)
+acceptString("Hello World", seq => seq.length < 100)
+
+/**
+ * Enables definition of functions which look more like built-in language constructs
+ */
+def acceptStringCurried(s: String)(pred: String => Boolean): Boolean = pred(s)
+
+acceptStringCurried("Hello World") {
+  seq => seq.length > 1
+}
+
+acceptStringCurried("Hello World") {
+  seq => seq.length < 100
+}
+
+/**
+ * Curried functions enable compiler for type inference
+ */
+def acceptCurried[T](something: T)(pred: T => Boolean): Boolean = pred(something)
+
+
+// types in predicate function can be omitted
+acceptCurried("Curry")(s => s.length > 0)
+acceptCurried("Curry")(_.length > 0)
+acceptCurried(15)(i => i > 0)
+acceptCurried(15)(_ > 0)
+
+
+// Type inference is not possible in uncurried version
+def accept[T](s: T, pred: T => Boolean): Boolean = pred(s)
+
+accept("Curry", (s: String) => s.length > 0)
+accept(15, (i: Int) => i > 0)
+
+// without currying this is not possible:
+//accept("Curry", s => s.length > 0)
+//accept("Curry", _.length > 0)
+//accept(15)(i => i > 0)
+//accept(15)(_ > 0)
+
+/**
+ * Currying must be used when working with implicit parameter lists.
+ *
+ * Implicit parameter lists are frequently used to inject dependencies into functions.
+ */
+def accept(s: String)(implicit pred: String => Boolean): Boolean = pred(s)
+
+implicit val isOink: String => Boolean = s => s == "Oink"
+
+accept("Yeeha")
+accept("Oink")
+
+// Show Example code from Play framework project with implicit request