泛函编程（16）－泛函状态－Functional State

初接触泛函状态觉着很不习惯。主要是在使用State数据类型时很难理解其中的原理，特别是泛函状态变迁机制（state transition mechanism）：怎么状态就起了变化，实在难以跟踪。我想这主要是因为状态变迁机制经过了函数组合，已经深深的埋藏在运行代码后面。上节我们讨论到RNG，对于了解State类型是个很好的开头。RNG简单描述了泛函方式的状态变迁及支持状态变迁所需要的数据结构和操作函数款式。

在上节我们提到过 type Rand[+A] = RNG => (A, RNG)，Rand是一个随意数产生函数。由于Rand是个类型，一个函数类型，所以可以被当作参数或者返回值来使用。我们把这个定义再扩展一下，变得更通用一些：type State[S, +A] = S => (A, S)。Rand就是State的一个特殊案例：type Rand[+A] = State[RNG, +A] 。我们称State为状态行为，即S => (A,S)是一个定义状态变迁方式的函数。State类型的状态变迁机制就是通过状态行为函数来确定的。再次聚焦一下我们设计State类型的目标：State类型不但可以使我们像设计其它类型一样封装一个较低阶类型元素并且提供一套状态变迁机制，而且状态变迁机制是泛函式的，自然隐性的。

我们先试试简单的State类型设计：

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

没错，就是这么简单，也是我刻意为之。注意状态行为函数run是State类的内部成员，我们有针对性的把一个State的状态变迁机制通过在构建State类时作为参数注入。然后产生的State实例就会按照我们期待的那样进行状态变迁了。case class自备了apply,这样我们可以直接使用State(???)创建State实例。我会把State(s => (a,s))写成State { s => (a,s)}，这样表达传入的是一段代码会更形象自然一点。State[]既然是一个高阶类型，那么我们应该也为它提供一套在管子内部进行元素操作的函数。切记！切记！在处理管子内封装元素值的同时要按照状态行为函数的要求对类型状态进行相应变迁。

先从高阶类型最基本的组件开始：

 object State {
     def unit[S,A](a: A) = State[S,A](s => (a, s))
 }

我们前面接触过这个unit。它就是一个封装元素值和状态都不转变的State实例。unit的唯一功能就是把低阶一级的封装元素类型a升格为State类型。

我们来编写一个State函数，切记！切记！要同时处理状态变迁机制：

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

在flatMap里我们用函数f处理了封装元素a, f(a)。同时我们又引用了状态行为函数run对传入的状态s进行了状态变迁 run(s)。

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

同样，map也实施了f(a),run(s)。map也可以用flatMap来实现。它们之间的分别只是f: A => B 和 A => State[S,B]。因为我们有unit, unit(a) = State[S,A]，unit(f(a)) = State[S,B]所以我们用unit把map的函数参数A升格就行了。用flatMap来实现map可以把map抽升到更高级：这样map就不用再理会那个状态行为函数了。

那么map2呢？

     def map2[B,C](sb: State[S,B])(f: (A,B) => C): State[S,C] = {
         flatMap {a => sb.map { b => f(a,b) }}
     }
     def map3[B,C,D](sb: State[S,B], sc: State[S,C])(f: (A,B,C) => D): State[S,D] = {
         flatMap {a => sb.flatMap {b => sc.map { c => f(a,b,c) }}}
     }

map2的功能是用封装元素类型函数(A,B) => C来把两个State管子里的元素结合起来。我们可以施用flatMap两次来把两个管子里的元素结合起来。对于map3我们可以再加一次。

另一种连续施用flatMap的表达方式：

     def map2_1[B,C](sb: State[S,B])(f: (A,B) => C): State[S,C] ={
         for {
             a <- this
             b <- sb
         } yield f(a,b)
     }
     def map3_1[B,C,D](sb: State[S,B], sc: State[S,C])(f: (A,B,C) => D): State[S,D] ={
         for {
             a <- this
             b <- sb
             c <- sc
         } yield f(a,b,c)
     }

以上的语法糖（syntatic sugar）for-comprehension让我们俨然进入了一个泛函世界，好像有了一种兴奋的感觉。这种表达形式简洁直白，更加容易理解。同样，在map2,map3里没有涉及到任何状态变迁的东西。我们实现了状态变迁的隐形操作。

下面举个切实例子来示范泛函状态：

 //Stack类型就是一个List[Int]，后面比较容易表达点
 type Stack = List[Int]
 //pop就是一个State实例。它的状态行为函数是partial function：把一个现成的List[Int]拆分成新的值和状态
 //即把第一个元素去掉放到值里
 def pop = State[Stack, Int]{ case x::xs => (x, xs) }
                                                   //> pop: => ch6.state.State[ch6.state.Stack,Int]
 //push就是一个State实例。它的状态行为函数把i压到一个现成的List[Int]上，跟值没有任何关系
 def push(i: Int) = State[Stack, Unit]{ case xs => ((), i :: xs ) }
                                                   //> push: (i: Int)ch6.state.State[ch6.state.Stack,Unit]
 def stackRun: State[Stack, Int] = {
     for {
         _ <- push(13)
         a <- pop
         b <- pop
     } yield a+b
 }                                                 //> stackRun: => ch6.state.State[ch6.state.Stack,Int]

 val (a, s) =stackRun.run(List(10,11,12))          //> a  : Int = 23
                                                   //| s  : ch6.state.Stack = List(11, 12)

在stackRun里我们没有在任何地方提到状态Stack，但看看运行结果(a,s)：不但返回值是正确的，而且Stack状态也默默地发生了转变。如果尝试从stackRun的代码里去分析状态是如何转变的是永远无法理解的，建议还是老老实实从头来吧。

泛函状态是一种隐形自动的变迁，那么如果我们需要打乱既定流程，手动设定或者临时读取状态时该怎么办呢？

 object State {
     def unit[S,A](a: A) = State[S,A](s => (a, s))
     def getState[S]: State[S,S] = State[S,S] { s => (s,s) }
   def setState[S](s: S): State[S,Unit] = State[S,Unit] { _ => ((),s)}

 }

还是通过状态行为函数来实现的。

 def stackRun: State[Stack, Int] = {
     for {
         _ <- push(13)
         a <- pop
         _ <- setState(List(8,9))
         b <- pop
         s1 <- getState
     } yield (a + b)
 }                                                 //> stackRun: => ch6.state.State[ch6.state.Stack,Int]

 val (a, s) =stackRun.run(List(10,11,12))          //> a  : Int = 21
                                                   //| s  : ch6.state.Stack = List(9)

我们可以临时将状态设置成List(8,9)。