纯函数式状态（2）

更为通用的状态行为数据类型
我们写过的函数——unit、map、map2、flatMap和sequence都不是专门为随机数使用的。它们都是处理状态行为的通用函数，不关心状态类型。比如map不关心它处理的RNG状态行为，我们可以给它一个更通用的签名。

def map[S, A, B](a: S => (A, S))(f: A => B): S => (B, S) = ???

接着将Rand也改为一个通用的签名，可以处理任何类型的状态。

type State[S, +A] = S => (A, S)

这里的State是对“携带状态的计算”或“状态行为”、“状态转换”，甚至是“指令”（statement）的缩写。我们或许想将它定义为自己的类：

case class State[S, +A](run: S => (A, S)) {

}

现在可以把Rand作为State的别名：

type Rand[A] = State[RNG, A]

练习 6.10
泛化unit、map、map2、flatMap和sequence函数，把他们尽量放在State类中，否则放在State伴生对象中。

case class State[S, +A](run: S => (A, S)) {
  
  def unit[B >: A](a: B): State[S, B] = State(s => (a, s))
  
  def map[B](f: A => B): State[S, B] = State{s =>
    val (a, s1) = run(s)
    (f(a), s1)
  }
  
  def map2[B, C](sb: State[S, B])(f: (A, B) => C): State[S, C] = State{s =>
    val (a, s1) = run(s)
    val (b, s2) = sb.run(s1)
    (f(a, b), s2)
  }

  def flatMap[B](f: A => State[S, B]): State[S, B] = State{s =>
    val (a, s1) = run(s)
    f(a).run(s1)
  }
  
}

object State {

  def sequence[S, A](fs: List[State[S, A]]): State[S, List[A]] = State {s =>
    def loop(n: Int, res: (List[A], S)): (List[A], S) = n match {
      case m if m < 0 => res
      case _ =>
        val (li, s1) = res
        val (a, s2) = fs(n).run(s1)
        loop(n - 1, (a :: li, s2))
    }
    loop(fs.length - 1, (Nil, s))
  }
}

纯函数式命令编程
我们实现了一些如map、map2之类的普通组合子，以及flatMap终极组合子，来处理状态从一个指令到另一个指令的传播。但是这么做失去了一些“命令语气”。看一下下面的例子：

  type Rand[A] = State[RNG, A]
  
  val int: Rand[Int] = State(_.nextInt)
  
  def ints(n: Int): Rand[List[Int]] = State{rng =>
    def loop(n: Int, res: (List[Int], RNG)): (List[Int], RNG) =
      n match {
        case 0 => res
        case _ => 
          val (li, rng) = res
          val (i, rng1) = rng.nextInt
          loop(n - 1, (i :: li, rng1))
      }
    loop(n, (Nil, rng))
  }
  
  val ns: Rand[List[Int]] =
    int.flatMap(x =>
      int.flatMap(y =>
        ints(x).map(xs =>
          xs.map(_ % y)
        )
      )
    )

这里做了什么不容易一下看出来，不过既然我们已经定义了map和flatMap，可以使用for推到来还原为命令式风格：

  val ns1: Rand[List[Int]] =
    for {
      x <- int
      y <- int
      xs <- ints(x)
    } yield xs.map(_ % y)

这段代码更容易读，也容易写，差不多一看便知道大概的意图，可见使用for 推到式使命令编程更容易些。