Rest of exercises regarding lists

Author: Javier de Silóniz Sandino

src/main/scala/fpinscalalib/FunctionalDataStructuresSection.scala

@@ -1,6 +1,7 @@
 package fpinscalalib
 
 import org.scalatest.{FlatSpec, Matchers}
+import fpinscalalib.List._
 
 /** @param name functional_data_structures
   */
@@ -88,7 +89,7 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
       case Cons(x, Cons(2, Cons(4, _))) => x
       case Nil => 42
       case Cons(x, Cons(y, Cons(3, Cons(4, _)))) => x + y
-      case Cons(h, t) => h + List.sum(t)
+      case Cons(h, t) => h + sum(t)
       case _ => 101
     }
     x shouldBe res0
@@ -111,8 +112,8 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listTakeAssert(res0: List[Int], res1: List[Int]) {
-    List.tail(List(1, 2, 3)) shouldBe res0
-    List.tail(List(1)) shouldBe res1
+    tail(List(1, 2, 3)) shouldBe res0
+    tail(List(1)) shouldBe res1
   }
 
   /**
@@ -130,8 +131,8 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listSetHeadAssert(res0: List[Int], res1: List[String]) {
-    List.setHead(List(1, 2, 3), 3) shouldBe res0
-    List.setHead(List("a", "b"), "c") shouldBe res1
+    setHead(List(1, 2, 3), 3) shouldBe res0
+    setHead(List("a", "b"), "c") shouldBe res1
   }
 
   /**
@@ -150,11 +151,11 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listDropAssert(res0: List[Int], res1: List[Int], res2: List[Int], res3: List[Int], res4: List[Int]) {
-    List.drop(List(1, 2, 3), 1) shouldBe res0
-    List.drop(List(1, 2, 3), 0) shouldBe res1
-    List.drop(List("a", "b"), 2) shouldBe res2
-    List.drop(List(1, 2), 3) shouldBe res3
-    List.drop(Nil, 1) shouldBe res4
+    drop(List(1, 2, 3), 1) shouldBe res0
+    drop(List(1, 2, 3), 0) shouldBe res1
+    drop(List("a", "b"), 2) shouldBe res2
+    drop(List(1, 2), 3) shouldBe res3
+    drop(Nil, 1) shouldBe res4
   }
 
   /**
@@ -173,10 +174,10 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listDropWhileAssert(res0: List[Int], res1: List[Int], res2: List[Int], res3: List[Int]) {
-    List.dropWhile(List(1, 2, 3), (x: Int) => x < 2) shouldBe res0
-    List.dropWhile(List(1, 2, 3), (x: Int) => x > 2) shouldBe res1
-    List.dropWhile(List(1, 2, 3), (x: Int) => x > 0) shouldBe res2
-    List.dropWhile(Nil, (x: Int) => x > 0) shouldBe res3
+    dropWhile(List(1, 2, 3), (x: Int) => x < 2) shouldBe res0
+    dropWhile(List(1, 2, 3), (x: Int) => x > 2) shouldBe res1
+    dropWhile(List(1, 2, 3), (x: Int) => x > 0) shouldBe res2
+    dropWhile(Nil, (x: Int) => x > 0) shouldBe res3
   }
 
   /**
@@ -196,8 +197,8 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listInitAssert(res0: List[Int], res1: List[Int]) {
-    List.init(List(1, 2, 3)) shouldBe res0
-    List.init(List(1)) shouldBe res1
+    init(List(1, 2, 3)) shouldBe res0
+    init(List(1)) shouldBe res1
   }
 
   /**
@@ -250,10 +251,10 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listFoldRightSumAssert(res0: Int,res1: Int, res2: Int, res3: Int, res4: Int, res5: Int, res6: List[Int], res7: Int, res8: Int, res9: Int, res10: Int) {
-    List.foldRight(Cons(1, Cons(2, Cons(3, Nil))), 0)((x,y) => x + y) shouldBe 6
-    res0 + List.foldRight(Cons(2, Cons(3, Nil)), 0)((x,y) => x + y) shouldBe 6
-    res1 + res2 + List.foldRight(Cons(3, Nil), 0)((x,y) => x + y) shouldBe 6
-    res3 + res4 + res5 + List.foldRight(res6, 0)((x,y) => x + y) shouldBe 6
+    foldRight(Cons(1, Cons(2, Cons(3, Nil))), 0)((x,y) => x + y) shouldBe 6
+    res0 + foldRight(Cons(2, Cons(3, Nil)), 0)((x,y) => x + y) shouldBe 6
+    res1 + res2 + foldRight(Cons(3, Nil), 0)((x,y) => x + y) shouldBe 6
+    res3 + res4 + res5 + foldRight(res6, 0)((x,y) => x + y) shouldBe 6
     res7 + res8 + res9 + res10 shouldBe 6
   }
 
@@ -263,7 +264,7 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
     */
 
   def listFoldRightNilConsAssert(res0: List[Int]) {
-    List.foldRight(List(1, 2, 3), Nil:List[Int])(Cons(_, _)) shouldBe res0
+    foldRight(List(1, 2, 3), Nil:List[Int])(Cons(_, _)) shouldBe res0
   }
 
   /**
@@ -276,5 +277,249 @@ object FunctionalDataStructuresSection extends FlatSpec with Matchers with org.s
 
     length(l) shouldBe 5
   }
+
+  /**
+    * Our implementation of `foldRight` is not tail-recursive and will result in a `StackOverflowError` for large lists
+    * (we say it's not `stack-safe`). Let's write another general list-recursion function, `foldLeft`, that is
+    * tail-recursive, using the techniques we discussed in the previous chapter:
+    *
+    * {{{
+    *   def foldLeft[A,B](l: List[A], z: B)(f: (B, A) => B): B =
+    *     l match {
+    *       case Nil => z
+    *       case Cons(h,t) => foldLeft(t, f(z,h))(f)
+    *     }
+    * }}}
+    *
+    * Let's write functions `sum`, `product` and `length` of a list using `foldLeft`:
+    */
+
+  def listFoldLeftSumProductLengthAssert(res0: Int, res1: Double, res2: Int, res3: Int): Unit = {
+    def sum3(l: List[Int]) = foldLeft(l, res0)(_ + _)
+    def product3(l: List[Double]) = foldLeft(l, res1)(_ * _)
+    def length2[A](l: List[A]): Int = foldLeft(l, res2)((acc,h) => acc + res3)
+
+    def listInts = List(1, 2, 3, 4, 5)
+    def listDoubles = List(1.0, 2.0, 3.0)
+    sum3(listInts) shouldBe 15
+    product3(listDoubles) shouldBe 6.0
+    length2(listInts) shouldBe 5
+  }
+
+  /**
+    * As we saw above, we can write the previous functions we implemented using `foldRight` with `foldLeft`. Let's continue
+    * with `reverse`:
+    *
+    * {{{
+    *   def reverse[A](l: List[A]): List[A] = foldLeft(l, List[A]())((acc, h) => Cons(h, acc))
+    * }}}
+    *
+    * In fact, we can write `foldLeft` in terms of `foldRight`, and the other way around:
+    *
+    * {{{ 
+    *   def foldRightViaFoldLeft[A,B](l: List[A], z: B)(f: (A,B) => B): B =
+    *     foldLeft(reverse(l), z)((b,a) => f(a,b))
+    *
+    *   def foldLeftViaFoldRight[A,B](l: List[A], z: B)(f: (B,A) => B): B =
+    *     foldRight(l, (b:B) => b)((a,g) => b => g(f(b,a)))(z)
+    * }}}
+    *
+    * The implementation of `foldRight` in terms of `reverse` and `foldLeft` is a common trick for avoiding stack overflows
+    * when implementing a strict `foldRight` function as we've done in this chapter. Note that the other implementation is
+    * more of theoretical interest - it isn't stack-safe and won't work for large lists.
+    *
+    */
+
+  /**
+    * Another function we can implement by using `foldRight` is `append`:
+    *
+    * {{{
+    *   def appendViaFoldRight[A](l: List[A], r: List[A]): List[A] =
+    *     foldRight(l, r)(Cons(_,_))
+    * }}}
+    *
+    * Take a look at its implementation and check how it works:
+    */
+
+  def listAppendAssert(res0: List[Int], res1: List[Int], res2: List[Int], res3: List[Int]): Unit = {
+    append(List(1, 2, 3), List(1, 2)) shouldBe res0
+    append(List(1, 2, 3), Nil) shouldBe res1
+    append(Nil, List(1, 2)) shouldBe res2
+    append(Nil, Nil) shouldBe res3
+  }
+
+  /**
+    * `foldRight` can also be useful to write a function `concat` that concatenates a list of lists into a single list.
+    * Take a look at its implementation:
+    *
+    * {{{
+    *   def concat[A](l: List[List[A]]): List[A] =
+    *     foldRight(l, Nil:List[A])(append)
+    * }}}
+    *
+    * Since `append` takes time proportional to its first argument, and this first argument never grows because of the
+    * right-associativity of `foldRight`, this function is linear in the total length of all lists.
+    *
+    */
+
+  /**
+    * Let's keep digging into the uses of `foldLeft` and `foldRight`, by implementing a function that transforms a list
+    * of integers by adding 1 to each element:
+    */
+
+  def listAdd1Assert(res0: Int): Unit = {
+    def add1(l: List[Int]): List[Int] = foldRight(l, Nil : List[Int])((h, t) => Cons(h + res0,t))
+    add1(List(1, 2, 3)) shouldBe List(2, 3, 4)
+  }
+
+  /**
+    * We can do something similar to turn each value in a List[Double] into a String:
+    *
+    * {{{
+    *   def doubleToString(l: List[Double]): List[String] =
+    *     foldRight(l, Nil:List[String])((h,t) => Cons(h.toString,t))
+    * }}}
+    */
+
+  /**
+    * Both `add1` and `doubleToString` modify each element in a list while maintaining its structure. We can generalize
+    * it in the following way:
+    *
+    * {{{
+    *   def map[A,B](l: List[A])(f: A => B): List[B] =
+    *     foldRight(l, Nil:List[B])((h,t) => Cons(f(h),t))
+    * }}}
+    *
+    * You may notice that we are using `foldRight` to implement `map`, even though it's not stack-safe. We can also
+    * use `foldRightViaFoldLeft` (that relies on reversing the original list), or use local mutation. Take a look at both
+    * alternatives:
+    *
+    * {{{
+    *   def map_1[A,B](l: List[A])(f: A => B): List[B] =
+    *     foldRightViaFoldLeft(l, Nil:List[B])((h,t) => Cons(f(h),t))
+    *
+    *   def map_2[A,B](l: List[A])(f: A => B): List[B] = {
+    *     val buf = new collection.mutable.ListBuffer[B]
+    *     def go(l: List[A]): Unit = l match {
+    *       case Nil => ()
+    *       case Cons(h,t) => buf += f(h); go(t)
+    *     }
+    *     go(l)
+    *     List(buf.toList: _*) // converting from the standard Scala list to the list we've defined here
+    *   }
+    * }}}
+    */
+
+  /**
+    * Let's apply the same principle as in `map` to remove elements from a list, starting with a function to remove all
+    * odd numbers from a List[Int]:
+    */
+  def listRemoveOdds(res0: Int, res1: Int): Unit = {
+    def removeOdds(l: List[Int]): List[Int] =
+      foldRight(l, Nil:List[Int])((h, t) => if (h % res0 == res1) Cons(h, t) else t)
+    removeOdds(List(1, 2, 3, 4, 5)) shouldBe List(2, 4)
+  }
+
+  /**
+    * Following the same principle, let's generalize the function above to be able to remove elements from a list unless
+    * they satisfy a given predicate:
+    *
+    * {{{
+    *   def filter[A](l: List[A])(f: A => Boolean): List[A] =
+    *     foldRight(l, Nil:List[A])((h,t) => if (f(h)) Cons(h,t) else t)
+    * }}}
+    *
+    * The same considerations regarding the different choices of implementations as in `map` apply to `filter`. The one
+    * above isn't stack-safe, so we should make a choice between using `foldRightViaFoldLeft` instead of `foldRight`, or
+    * perform local mutations.
+    */
+
+  /**
+    * We're going to implement a new function that works like `map` except that the function given will return a list
+    * instead of a single result, and that list should be inserted into the final resulting list:
+    *
+    * {{{
+    *   def flatMap[A,B](l: List[A])(f: A => List[B]): List[B] =
+    *     concat(map(l)(f))
+    * }}}
+    *
+    * Let's try it out:
+    */
+
+  def listFlatMapAssert(res0: List[Int]): Unit = {
+    flatMap(List(1, 2, 3))(i => List(i, i)) shouldBe res0
+  }
+
+  /**
+    * We can also implement `filter` using `flatMap`:
+    *
+    * {{{
+    *   def filterViaFlatMap[A](l: List[A])(f: A => Boolean): List[A] =
+    *     flatMap(l)(a => if (f(a)) List(a) else Nil)
+    * }}}
+    *
+    */
+
+  /**
+    * Now we're going to write a function that accepts two lists of integers and constructs a new list by adding
+    * corresponding elements. For example, `List(1, 2, 3)` and `List(4, 5, 6)` become `List(5, 7, 9)`:
+    *
+    * {{{
+    *   def addPairwise(a: List[Int], b: List[Int]): List[Int] = (a,b) match {
+    *     case (Nil, _) => Nil
+    *     case (_, Nil) => Nil
+    *     case (Cons(h1,t1), Cons(h2,t2)) => Cons(h1+h2, addPairwise(t1,t2))
+    *   }
+    * }}}
+    *
+    * We can generalize the function above so that it's not specific to integers or addition, `zipWith`:
+    *
+    * {{{
+    *   def zipWith[A,B,C](a: List[A], b: List[B])(f: (A,B) => C): List[C] = (a,b) match {
+    *     case (Nil, _) => Nil
+    *     case (_, Nil) => Nil
+    *     case (Cons(h1,t1), Cons(h2,t2)) => Cons(f(h1,h2), zipWith(t1,t2)(f))
+    *   }
+    * }}}
+    *
+    * Let's try out `zipWith` in the following exercise:
+    */
+
+  def listZipWithAssert(res0: List[String], res1: List[String]): Unit = {
+    zipWith(List("a", "b", "c"), List("A", "B", "C"))(_ + _) shouldBe res0
+    zipWith(List(1, 2, 3), List(4, 5, 6))(_.toString + _.toString()) shouldBe res1
+  }
+
+  /**
+    * As a final example to work with lists, let's implement a `hasSubsequence` function for checking whether a `List`
+    * contains another `List` as a subsequence. For instance, `List(1, 2, 3, 4)` would have `List(1, 2)`, `List(2, 3)`
+    * and `List(4)` as subsequences, among others:
+    *
+    * {{{
+    *   @annotation.tailrec
+    *     def startsWith[A](l: List[A], prefix: List[A]): Boolean = (l,prefix) match {
+    *       case (_,Nil) => true
+    *       case (Cons(h,t),Cons(h2,t2)) if h == h2 => startsWith(t, t2)
+    *       case _ => false
+    *     }
+    *
+    *   @annotation.tailrec
+    *   def hasSubsequence[A](sup: List[A], sub: List[A]): Boolean = sup match {
+    *     case Nil => sub == Nil
+    *     case _ if startsWith(sup, sub) => true
+    *     case Cons(h,t) => hasSubsequence(t, sub)
+    *   }
+    * }}}
+    *
+    * Take a deep look at the implementation of this function, and then try it out in the next exercise:
+    */
+
+  def listHasSubsequenceAssert(res0: Boolean, res1: Boolean, res2: Boolean): Unit = {
+    def l = List(1, 2, 3, 4, 5)
+
+    hasSubsequence(l, List(2, 3)) shouldBe res0
+    hasSubsequence(l, List(0, 1)) shouldBe res1
+    hasSubsequence(l, Nil) shouldBe res2
+  }
 }
 

src/test/scala/fpinscalalib/FunctionalDataStructuresSpec.scala

@@ -52,4 +52,34 @@ class FunctionalDataStructuresSpec extends Spec with Checkers {
   def `list length with foldRight asserts` = {
     check(Test.testSuccess(FunctionalDataStructuresSection.listLengthAssert _, 0 :: 1 :: HNil))
   }
+
+  def `list foldLeft sum product length asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listFoldLeftSumProductLengthAssert _, 0 :: 1.0 :: 0 :: 1 :: HNil))
+  }
+
+  def `list foldLeft append asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listAppendAssert _,
+      List(1, 2, 3, 1, 2) :: List(1, 2, 3) :: List(1, 2) :: List[Int]() :: HNil))
+  }
+
+  def `list add 1 asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listAdd1Assert _, 1 :: HNil))
+  }
+
+  def `list remove odds asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listRemoveOdds _, 2 :: 0 :: HNil))
+  }
+
+  def `list flatMap asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listFlatMapAssert _, List(1, 1, 2, 2, 3, 3) :: HNil))
+  }
+
+  def `list zipWith asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listZipWithAssert _,
+      List("aA", "bB", "cC") :: List("14", "25", "36") :: HNil))
+  }
+
+  def `list hasSubsequence asserts` = {
+    check(Test.testSuccess(FunctionalDataStructuresSection.listHasSubsequenceAssert _, true :: false :: true :: HNil))
+  }
 }