在函数式解决方案中，以值的方式返回错误是更加安全，符合引用透明，并且可以通过高阶函数保存异常的优点--统一处理错误逻辑。
异常破坏了引用透明并引入了上下文依赖。
异常不是类型安全的。
Option数据类型

sealed trait Option[+A] {
  
}

case object None extends Option[Nothing]

case class Some[+A](a: A) extends Option[A]

练习 4.1
对Option实现所有的函数，在实现每个函数的时候试着去考虑它有什么意义，在什么场景下使用。

  def map[B](f: A => B): Option[B] = this match {
    case None => None
    case Some(a) => Some(f(a))  
  }
  
  def flatMap[B](f: A => Option[B]): Option[B] = this match {
    case None => None
    case Some(a) => f(a)
  }
  
  def getOrElse[B >: A](default: => B): B = this match {
    case None => default
    case Some(a) => a
  }
  
  def orElse[B >: A](ob: Option[B]): Option[B] = this match {
    case None => ob
    case Some(a) => Some(a)  
  }
  
  def filter(f: A => Boolean): Option[A] = this match {
    case Some(a) if f(a) => Some(a)
    case _ => None  
  }

练习 4.2
根据flatMap函数实现一个variance（方差）函数。

  def mean(xs: Seq[Double]): Option[Double] =
    if(xs.isEmpty) None
    else Some(xs.sum / xs.length)

  def variance(xs: Seq[Double]): Option[Double] = 
    mean(xs).map(m =>
      xs.map(x => Math.pow(x-m, 2)).sum / xs.length
    )

可以通过升格（lift）的方式将普通函数升格为对Option操作的函数。
练习 4.3
写一个泛化的函数map2，使一个二元函数来组合两个Option的值。

  def map2[A, B, C](oa: Option[A], ob: Option[B])(f: (A, B) => C): Option[C] =
    oa.flatMap{a =>
      ob.map{b =>
        f(a, b)
      }
    }

  def map2[A, B, C](oa: Option[A], ob: Option[B])(f: (A, B) => C): Option[C] =
    for {
      a <- oa
      b <- ob
    } yield f(a, b)

练习 4.5
写一个sequence函数，将一个Option的列表结合为一个Option

  def sequence[A](li: List[Option[A]]): Option[List[A]] = {
    def loop(n: Int, res: Option[List[A]]): Option[List[A]] = n match {
      case -1 => res
      case _ => li(n) match {
        case None => None
        case Some(a) => loop(n - 1, res.map(a :: _))
      }
    }
    loop(li.length - 1, Some(Nil))
  }

练习 4.6
实现一个函数，它直接使用map和sequence但是效率更好，只遍历一次列表。

  def traverse[A, B](li: List[A])(f: A => Option[B]): Option[List[B]] =
    sequence(li.map(f))