Functional Programming in Scala第三章练习

学习scala的练习，同学们请多多指教

package com.hotcharm.www

import scala.annotation.tailrec

object Chapter3 {

  sealed trait List[+A]
  case object Nil extends List[Nothing]
  case class Cons[+A](head: A, tail: List[A]) extends List[A]

  object List {

    def isEmpty[A](as: List[A]): Boolean = as match {
      case Nil => true
      case _ => false
    }

    def head[A](as: List[A]): A = as match {
      case Nil => throw new Exception("list is empty, no head!")
      case Cons(x, xs) => x
    }

    def sum(ints: List[Int]): Int = ints match {
      case Nil => 0
      case Cons(x, xs) => x + sum(xs)
    }

    def product(ds: List[Double]): Double = ds match {
      case Nil => 1.0
      case Cons(0.0, _) => 0.0
      case Cons(x, xs) => x * product(xs)
    }

    def apply[A](as: A*): List[A] =
      if (as.isEmpty) Nil
      else Cons(as.head, apply(as.tail: _*))

    /**
     * EXERCISE 3.2
     * Implement the function tail for removing the first element of a List. Note that the
     * function takes constant time. What are different choices you could make in your
     * implementation if the List is Nil? We’ll return to this question in the next chapter.
     */
    def tail[B](lst: List[B]): List[B] = lst match {
      case Nil => Nil
      case Cons(_, xs) => xs
    }

    /**
     * EXERCISE 3.4
     * Generalize tail to the function drop, which removes the first n elements from a list.
     * Note that this function takes time proportional only to the number of elements being
     * dropped—we don’t need to make a copy of the entire List.
     */
    @annotation.tailrec
    def drop[A](l: List[A], n: Int): List[A] = {
      if (n <= 1) tail(l) else drop(tail(l), n - 1)
    }

    /**
     * EXERCISE 3.5
     * Implement dropWhile, which removes elements from the List prefix as long as they
     * match a predicate.
     */
    @annotation.tailrec
    def dropWhile[A](l: List[A], f: A => Boolean): List[A] = l match {
      case Nil => Nil
      case Cons(h, t) => if (f(h)) dropWhile(t, f) else l
    }

    /**
     * EXERCISE 3.6
     * Not everything works out so nicely. Implement a function, init, that returns a List
     * consisting of all but the last element of a List. So, given List(1,2,3,4), init will
     * return List(1,2,3). Why can’t this function be implemented in constant time like
     * tail?
     */
    def init[A](l: List[A]): List[A] = reverse(tail(reverse(l)))

    def reverse[A](l: List[A]): List[A] = {
      @annotation.tailrec
      def reverseIter[A](l: List[A], rl: List[A]): List[A] = l match {
        case Nil => rl
        case Cons(h, t) => reverseIter(t, Cons(h, rl))
      }
      reverseIter(l, Nil)
    }

    /**
     * EXERCISE 3.7
     * Can product, implemented using foldRight, immediately halt the recursion and
     * return 0.0 if it encounters a 0.0? Why or why not? Consider how any short-circuiting
     * might work if you call foldRight with a large list. This is a deeper question that we’ll
     * return to in chapter 5.
     */

    /**
     * EXERCISE 3.9
     * Compute the length of a list using foldRight.
     * def length[A](as: List[A]): Int
     */
    def length[A](as: List[A]): Int = foldRight(as, 0)((_, cnt) => cnt + 1)

    /**
     * EXERCISE 3.10
     * Our implementation of foldRight is not tail-recursive and will result in a StackOverflowError
     * for large lists (we say it’s not stack-safe). Convince yourself that this is the
     * case, and then write another general list-recursion function, foldLeft, that is
     * tail-recursive, using the techniques we discussed in the previous chapter. Here is its
     * signature:
     * def foldLeft[A,B](as: List[A], z: B)(f: (B, A) => B): B
     */
    @annotation.tailrec
    def foldLeft[A, B](as: List[A], z: B)(f: (B, A) => B): B = as match {
      case Nil => z
      case Cons(x, xs) => foldLeft(xs, f(z, x))(f)
    }

    /**
     * EXERCISE 3.12
     * Write a function that returns the reverse of a list (given List(1,2,3) it returns
     * List(3,2,1)). See if you can write it using a fold.
     */
    def reverse2[A](as: List[A]): List[A] = foldLeft(as, List[A]())((l, b) => Cons(b, l))

    /**
     * EXERCISE 3.13
     * Hard: Can you write foldLeft in terms of foldRight? How about the other way
     * around? Implementing foldRight via foldLeft is useful because it lets us implement
     * foldRight tail-recursively, which means it works even for large lists without overflowing
     * the stack.
     */
    def foldRight[A, B](as: List[A], z: B)(f: (A, B) => B): B = {
      foldLeft(reverse(as), z)((a, b) => f(b, a))
    }

    /**
     * EXERCISE 3.14
     * Implement append in terms of either foldLeft or foldRight.
     */
    def append[A](as1: List[A], as2: List[A]): List[A] = {
      foldRight(as1, as2)(Cons(_, _))
    }

    /**
     * EXERCISE 3.15
     * Hard: Write a function that concatenates a list of lists into a single list. Its runtime
     * should be linear in the total length of all lists. Try to use functions we have already
     * defined.
     */
    def concatLists[A](ass: List[List[A]]) = {
      foldLeft(ass, List[A]())((z, as) => append(z, as))
    }

    /**
     * EXERCISE 3.18
     * Write a function map that generalizes modifying each element in a list while maintaining
     * the structure of the list. Here is its signature:12
     * def map[A,B](as: List[A])(f: A => B): List[B]
     */
    def map[A, B](as: List[A])(f: A => B): List[B] = {
      foldRight(as, List[B]())((a, z) => Cons(f(a), z))
    }

    /**
     * EXERCISE 3.16
     * Write a function that transforms a list of integers by adding 1 to each element.
     * (Reminder: this should be a pure function that returns a new List!)
     */
    def allAddOne(l: List[Int]): List[Int] = {
      map(l)((x: Int) => (x + 1))
    }

    /**
     * EXERCISE 3.17
     * Write a function that turns each value in a List[Double] into a String. You can use
     * the expression d.toString to convert some d: Double to a String.
     */
    def doubleLst2StrLst(l: List[Double]): List[String] = {
      map(l)((x: Double) => x.toString)
    }

    /**
     * EXERCISE 3.19
     * Write a function filter that removes elements from a list unless they satisfy a given
     * predicate. Use it to remove all odd numbers from a List[Int].
     * def filter[A](as: List[A])(f: A => Boolean): List[A]
     */
    def filter[A](as: List[A])(f: A => Boolean): List[A] = {
      foldRight(as, List[A]())((a, z) => (if (f(a)) Cons(a, z) else z))
    }

    /**
     * EXERCISE 3.20
     * Write a function flatMap 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. Here is its signature:
     * def flatMap[A,B](as: List[A])(f: A => List[B]): List[B]
     * For instance, flatMap(List(1,2,3))(i => List(i,i)) should result in
     * List(1,1,2,2,3,3).
     */
    def flatMap[A, B](as: List[A])(f: A => List[B]): List[B] = concatLists(map(as)(f))

    /**
     * EXERCISE 3.21
     * Use flatMap to implement filter.
     */
    def filter2[A](as: List[A])(f: A => Boolean): List[A] = {
      flatMap(as)(x => if (f(x)) List(x) else Nil)
    }

    /**
     * EXERCISE 3.22
     * Write a function that accepts two lists 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 zipAddIntLists(as1: List[Int], as2: List[Int]): List[Int] = {
      zipWith(as1, as2, (x: Int, y: Int) => (x + y))
    }

    /**
     * EXERCISE 3.23
     * Generalize the function you just wrote so that it’s not specific to integers or addition.
     * Name your generalized function zipWith.
     */
    def zipWith[A](as1: List[A], as2: List[A], f: (A, A) => A): List[A] = {
      @annotation.tailrec
      def zipIter(as1: List[A], as2: List[A], r: List[A]): List[A] = {
        if (isEmpty(as1) || isEmpty(as2))
          r
        else
          zipIter(tail(as1), tail(as2), Cons(f(head(as1), head(as2)), r))
      }
      reverse(zipIter(as1, as2, List[A]()))
    }

    def take[A](as: List[A], n: Int): List[A] = {
      @annotation.tailrec
      def takeIter[A](as: List[A], n: Int, r: List[A]): List[A] = {
        if (n <= 0 || isEmpty(as))
          r
        else
          takeIter(tail(as), n - 1, Cons(head(as), r))
      }
      reverse(takeIter(as, n, List[A]()))
    }
    /**
     * EXERCISE 3.24
     * Hard: As an example, implement hasSubsequence 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. You may have
     * some difficulty finding a concise purely functional implementation that is also efficient.
     * That’s okay. Implement the function however comes most naturally. We’ll
     * return to this implementation in chapter 5 and hopefully improve on it. Note: Any
     * two values x and y can be compared for equality in Scala using the expression x == y.
     * def hasSubsequence[A](sup: List[A], sub: List[A]): Boolean
     */
    def hasSubsequence[A](sup: List[A], sub: List[A]): Boolean = {
      val supLen = length(sup)
      val subLen = length(sub)
      val ls = take(sup, subLen)
      if (supLen >= subLen)
        (ls == sub) || hasSubsequence(tail(sup), sub)
      else
        false
    }
  }

  sealed trait Tree[+A]
  case class Leaf[A](value: A) extends Tree[A]
  case class Branch[A](left: Tree[A], right: Tree[A]) extends Tree[A]

  object Tree {
    /**
     * EXERCISE 3.25
     * Write a function size that counts the number of nodes (leaves and branches) in a tree.
     */
    def size[A](t: Tree[A]): Int = t match {
      case Leaf(_) => 1
      case Branch(l, r) => 1 + size(l) + size(r)
    }

    /**
     * EXERCISE 3.26
     * Write a function maximum that returns the maximum element in a Tree[Int]. (Note:
     * In Scala, you can use x.max(y) or x max y to compute the maximum of two integers x
     * and y.)
     */
    def maximum(t: Tree[Int]): Int = t match {
      case Leaf(v) => v
      case Branch(l, r) => maximum(l) max maximum(r)
    }

    /**
     * EXERCISE 3.27
     * Write a function depth that returns the maximum path length from the root of a tree
     * to any leaf.
     */
    def depth[A](t: Tree[A]): Int = t match {
      case Leaf(_) => 1
      case Branch(l, r) => 1 + (depth(l) max depth(r))
    }

    /**
     * EXERCISE 3.28
     * Write a function map, analogous to the method of the same name on List, that modifies
     * each element in a tree with a given function.
     */
    def map[A, B](t: Tree[A], f: A => B): Tree[B] = t match {
      case Leaf(v) => Leaf(f(v))
      case Branch(l, r) => Branch(map(l, f), map(r, f))
    }

    /**
     * EXERCISE 3.29
     * Generalize size, maximum, depth, and map, writing a new function fold that abstracts
     * over their similarities. Reimplement them in terms of this more general function. Can
     * you draw an analogy between this fold function and the left and right folds for List?
     */
    def fold[A, B](t: Tree[A], fl: (A) => B, fb: (B, B) => B): B = t match {
      case Leaf(v) => fl(v)
      case Branch(l, r) => fb(fold(l, fl, fb), fold(r, fl, fb))
    }

    def size2[A](t: Tree[A]): Int = fold(t, (v: A) => 1, (i: Int, j: Int) => i + j + 1)

    def maximum2(t: Tree[Int]): Int = fold(t, (v: Int) => v, (i: Int, j: Int) => if (i >= j) i else j)

    def depth2[A](t: Tree[A]): Int = fold(t, (v: A) => 1, (i: Int, j: Int) => 1 + (i max j))

    def map2[A, B](t: Tree[A], f: A => B): Tree[B] = fold(t, (v: A) => Leaf(f(v)), (t1: Tree[B], t2: Tree[B]) => Branch(t1, t2))
  }

}

package com.hotcharm.www

import org.scalatest._
import Chapter3._
import Chapter3.List._

class TestChapter3 extends FunSuite {

  val x = List(1, 2, 3, 4, 5) match {
    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 + sum(t)
    case _ => 101
  }

  test("x is first add second") {
    assert(x == 3)
  }

  test("drop") {
    val l1: List[Int] = List(1, 3, 5, 4, 6)
    assert(drop(l1, 2) == List(5, 4, 6))
  }

  test("dropWhile") {
    val l: List[Int] = List(1, 3, 5, 4, 6)
    assert(dropWhile(l, (x: Int) => x < 4) == List(5, 4, 6))
    assert(dropWhile(l, (x: Int) => x > 7) == l)
  }

  test("reverse") {
    val l3: List[Int] = List(1, 3, 5)
    assert(reverse(l3) == List(5, 3, 1))
  }

  test("init") {
    val l4 = List(1, 3, 4, 6)
    assert(init(l4) == List(1, 3, 4))
  }

  /*
   * EXERCISE 3.8
   * See what happens when you pass Nil and Cons themselves to foldRight, like this:
   * foldRight(List(1,2,3), Nil:List[Int])(Cons(_,_)). What do you think this
   * says about the relationship between foldRight and the data constructors of List?
   */
  test("EXERCISE 3.8") {
    val l5 = List(1, 2, 3)
    val l6 = foldRight(l5, Nil: List[Int])(Cons(_, _))
    println(l6)
  }

  test("length") {
    val l7 = List(1, 2, 3, 4)
    val l8 = Nil
    assert(length(l7) == 4)
    assert(length(l8) == 0)
  }

  test("foldLeft tail rec") {
    val l9 = List(1, 2, 3, 4, 5)
    assert(foldLeft(l9, 0)(_ + _) == 15)
  }

  test("reverse2 use fold") {
    val l10 = List(1, 2, 3, 4, 5)
    val l11 = List(5, 4, 3, 2, 1)
    assert(reverse2(l10) == l11)
  }

  test("append") {
    val l10 = List(1, 2)
    val l11 = List(5, 4, 3)
    assert(append(l10, l11) == List(1, 2, 5, 4, 3))
  }

  test("concatLists") {
    val l10 = List(1, 2)
    val l11 = List(5, 4, 3)
    val lss = List(l10, l11)
    assert(concatLists(lss) == List(1, 2, 5, 4, 3))
  }

  test("allAddOne") {
    val l = List(1, 3, 5)
    assert(allAddOne(l) == List(2, 4, 6))
  }

  test("doubleLst2StrLst") {
    val l = List(1.0, 3.4, 5.6)
    val l2 = List("1.0", "3.4", "5.6")
    assert(doubleLst2StrLst(l) == l2)
  }

  test("filter") {
    val l = List(1, 2, 5, 4, 3)
    assert(filter(l)(_ % 2 == 0) == List(2, 4))
  }

  test("flatMap") {
    assert(flatMap(List(1, 2, 3))(i => List(i, i)) == List(1, 1, 2, 2, 3, 3))
  }

  test("filter2") {
    val l = List(1, 2, 5, 4, 3)
    assert(filter2(l)(_ % 2 == 0) == List(2, 4))

  }

  test("zipAddIntLists") {
    assert(zipAddIntLists(List(1, 2, 3), List(4, 5, 6)) == List(5, 7, 9))
    assert(zipAddIntLists(List(1, 2, 3), List(4, 5)) == List(5, 7))
  }

  test("hasSubsequence") {
    assert(hasSubsequence(List(1, 3, 5, 6, 7), List(3, 5, 6)))
    assert(!hasSubsequence(List(1, 3, 5, 6, 7), List(13, 5, 6)))

  }

  test("tree size") {
    val t = Branch(Leaf(1), Branch(Leaf(2), Branch(Leaf(3), Leaf(4))))
    assert(Tree.size(t) == 7)
    assert(Tree.size2(t) == 7)
  }

  test("tree maximum") {
    val t = Branch(Leaf(1), Branch(Leaf(2), Branch(Leaf(3), Leaf(4))))
    assert(Tree.maximum(t) == 4)
    assert(Tree.maximum2(t) == 4)
  }
  
  test("tree depth") {
    val t = Branch(Leaf(1), Branch(Leaf(2), Branch(Leaf(3), Leaf(4))))
    assert(Tree.depth(t) == 4)
    assert(Tree.depth2(t) == 4)
  }
  
  test("tree map"){
   val t = Branch(Leaf(1), Branch(Leaf(2), Branch(Leaf(3), Leaf(4))))
   val t1 = Branch(Leaf("1"), Branch(Leaf("2"), Branch(Leaf("3"), Leaf("4"))))
   assert(Tree.map(t, (x:Int) => x.toString()) == t1)
   assert(Tree.map2(t, (x:Int) => x.toString()) == t1)
  }

}