更为通用的状态行为数据类型
我们写过的函数——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 推到式使命令编程更容易些。
