泛函编程（31）－泛函IO：Free Monad－Running free
在上节我们介绍了Free Monad的基本情况。可以说Free Monad又是一个以数据结构替换程序堆栈的实例。实际上Free Monad的功能绝对不止如此，以heap换stack必须成为Free Monad的运算模式，这样我们才可以放心的使用Free Monad所产生的Monadic编程语言了。前面我们介绍了Trampoline的运算模式可以有效解决堆栈溢出问题，而上节的Free Monad介绍里还没有把Free Monad与Trampoline运算模式挂上钩。我们先考虑一下如何在Free Monad数据类型里引入Trampoline运算模式。
我们先对比一下Tranpoline和Free这两个数据类型的基本结构：
trait Free[F[_],A] {
private case class FlatMap[B](a: Free[F,A], f:A => Free[F,B]) extends Free[F,B]
def unit(a: A) = Return(a)
def flatMap[B](f: A => Free[F,B])(implicit F: Functor[F]): Free[F,B] = this match {
case Return(a) => f(a)
case Suspend(k) => Suspend(F.map(k)( _ flatMap f))
case FlatMap(b,g) => FlatMap(b, x => g(x) flatMap f) //FlatMap(b, g andThen (_ flatMap f))
}
def map[B](f: A => B)(implicit F: Functor[F]): Free[F,B] = flatMap(a => Return(f(a)))
}
case class Return[F[_],A](a: A) extends Free[F,A]
case class Suspend[F[_],A](ffa: F[Free[F,A]]) extends Free[F,A]
trait Trampoline[A] {
private case class FlatMap[B](a: Trampoline[A], f: A => Trampoline[B]) extends Trampoline[B]
final def runT: A = resume match {
case Right(a) => a
case Left(k) => k().runT
}
def unit[A](a: A) = Done(a)
def flatMap[B](f: A => Trampoline[B]): Trampoline[B] = this match {
// case FlatMap(b,g) => FlatMap(b, g andThen (_ flatMap f)
// case FlatMap(b,g) => FlatMap(b, x => FlatMap(g(x),f))
case FlatMap(b,g) => FlatMap(b, x => g(x) flatMap f)
case x => FlatMap(x,f)
}
def map[B](f: A => B): Trampoline[B] = flatMap(a => More(() => Done(f(a))))
final def resume: Either[() => Trampoline[A],A] = this match {
case Done(a) => Right(a)
case More(k) => Left(k)
case FlatMap(a,f) => a match {
case Done(v) => f(v).resume
case More(k) => Left(() => FlatMap(k(),f))
case FlatMap(b,g) => FlatMap(b, g andThen (_ flatMap f)).resume
}
}
}
case class Done[A](a: A) extends Trampoline[A]
case class More[A](k: () => Trampoline[A]) extends Trampoline[A]
这两个数据类型的设计目的都是为了能逐步运行算法：按照算法运算的状态确定下一步该如何运行。这个F[Free[F,A]]就是一个循环递归结构，里面保存了运算当前状态和下一步运算。
我们曾说如果一个数据类型能有个Functor实例，那么我们就可以用它来产生一个Free Monad。这个要求从上面Free[F,A]类型里的map,flatMap可以了解：我们用了implicit F: Functor[F]参数，因为必须有个Functor实例F才能实现map和flatMap。
为了实现Free Monad在运行中采用Trampoline运行机制，我们可以像Trampoline数据类型一样来实现resume,这个确定每一步运算方式的函数：
trait Free[F[_],A] {
private case class FlatMap[B](a: Free[F,A], f:A => Free[F,B]) extends Free[F,B]
def unit(a: A) = Return(a)
def flatMap[B](f: A => Free[F,B])(implicit F: Functor[F]): Free[F,B] = this match {
case Return(a) => f(a)
case Suspend(k) => Suspend(F.map(k)( _ flatMap f))
case FlatMap(b,g) => FlatMap(b, x => g(x) flatMap f) //FlatMap(b, g andThen (_ flatMap f))
}
def map[B](f: A => B)(implicit F: Functor[F]): Free[F,B] = flatMap(a => Return(f(a)))
final def resume(implicit F: Functor[F]): Either[F[Free[F,A]],A] = this match {
case Return(a) => Right(a)
case Suspend(k) => Left(k)
case FlatMap(a,f) => a match {
case Return(v) => f(v).resume
case Suspend(k) => Left(F.map(k)(_ flatMap f))
case FlatMap(b,g) => FlatMap(b, g andThen (_ flatMap f)).resume
}
}
}
case class Return[F[_],A](a: A) extends Free[F,A]
case class Suspend[F[_],A](ffa: F[Free[F,A]]) extends Free[F,A]
Free类型的resume函数与Trampoline的基本一致，只有返回类型和增加了参数implicit F: Functor［F]，因为Free[F,A]的F必须是个Functor：用Functor F可以产生Free[F,A]。
我们用个实际例子来体验一下用Functor产生Free：
我们可以用上一节的Interact类型：
trait Interact[A]
case class Ask(prompt: String) extends Interact[String]
case class Tell(msg: String) extends Interact[Unit]
这个类型太简单了，太单纯了。我还没想到如何得出它的Functor实例。好像没办法实现那个map函数。那么如果修改一下这个Interact类型：
trait Interact[A]
case class Ask[A](prompt: String, next: A) extends Interact[A]
case class Tell[A](msg: String, next: A) extends Interact[A]
这个新类型的两个状态Ask,Tell都增加了个参数next，代表下一步操作。实际上我们是用map来运行next的。这样我们就可以得出Interact的Functor实例。
trait Interact[A]
case class Ask[A](prompt: String, next: A) extends Interact[A]
case class Tell[A](msg: String, next: A) extends Interact[A]
implicit val interactFunctor = new Functor[Interact] {
def map[A,B](ia: Interact[A])(f: A => B): Interact[B] = ia match {
case Ask(x,n) => Ask(x,f(n))
case Tell(x,n) => Tell(x,f(n))
}
} //> interactFunctor : ch13.ex1.Functor[ch13.ex1.Interact] = ch13.ex1$$anonfun$
从上面的Functor实例中我们可以看到如何通过map的f(n)来运行下一步骤next。
接下来我们要把Interact类型升格到Free类型：
def liftF[F[_],A](fa: F[A])(implicit F: Functor[F]): Free[F,A] = {
Suspend(F.map(fa)(a => Return(a)))
} //> liftF: [F[_], A](fa: F[A])(implicit F: ch13.ex1.Functor[F])ch13.ex1.Free[F,
//| A]
implicit def LiftInteract[A](ia: Interact[A]): Free[Interact,A] = liftF(ia)
//> LiftInteract: [A](ia: ch13.ex1.Interact[A])ch13.ex1.Free[ch13.ex1.Interact,
//| A]
val prg = for {
first <- Ask("What's your first name?",())
last <- Ask("What's your last name?",())
_ <- Tell(s"Hello $first $last",())
} yield () //> prg : ch13.ex1.Free[ch13.ex1.Interact,Unit] = Suspend(Ask(What's your firs
//| t name?,Suspend(Ask(What's your last name?,Suspend(Tell(Hello () (),Return(
//| ())))))))
看，把Interact升格后就可以使用for-comprehension了。
还是那句话：用一个有Functor实例的类型就可以产生一个Free Monad。然后我们可以用这个产生的Monad来在for-comprehension里面编写一个算法。
解译运算(Interpret)是Free Monad的Interpreter功能。我们说过要把Trampoline运行机制引入Free Monad运算：
def foldMap[G[_]](f: F ~> G)(implicit F: Functor[F], G: Monad[G]): G[A] = resume match {
case Right(a) => G.unit(a)
case Left(k) => G.flatMap(f(k))(_ foldMap f)
}
foldMap通过调用resume引入了Trampoline运行机制。
前面介绍的Free Monad相对都比较简单。实际上Free Monad的Suspend处理可以是很复杂的，包括返回结果及接受输入等任何组合。下面我们再看一个较复杂的例子：我们可以把State视为一种简单的状态转变编程语言，包括读取及设定状态两种操作指令：
trait StateF[S,A]
case class Get[S,A](f: S => A) extends StateF[S,A]
case class Put[S,A](s: S, a: A) extends StateF[S,A]
我们先看看嫩不能获取StateF的Functor实例：
mplicit def stateFFunctor[S] = new Functor[({type l[x] = StateF[S,x]})#l] {
def map[A,B](sa: StateF[S,A])(f: A => B): StateF[S,B] = sa match {
case Get(g) => Get( s => f(g(s)) )
case Put(s,a) => Put(s, f(a))
}
} //> stateFFunctor: [S]=> ch13.ex1.Functor[[x]ch13.ex1.StateF[S,x]]
既然有了Functor实例，那么我们可以用来产生Free Monad:
type FreeState[S,A] = Free[({type l[x] = StateF[S,x]})#l, A]
Free[F,A]里的Functor F只接受一个类型参数。StateF[S,A]有两个类型参数，我们必须用type lambda来解决类型参数匹配问题。
现在我们已经得到了一个FreeState Monad。下面接着实现FreeState的基础组件函数：
def unit[S,A](a: A): FreeState[S,A] = Return[({type l[x] = StateF[S,x]})#l, A](a)
//> unit: [S, A](a: A)ch13.ex1.FreeState[S,A]
def getState[S]: FreeState[S,S] = Suspend[({type l[x] = StateF[S,x]})#l, S](
Get(s => Return[({type l[x] = StateF[S,x]})#l, S](s)))
//> getState: [S]=> ch13.ex1.FreeState[S,S]
def setState[S](s: S): FreeState[S,Unit] = Suspend[({type l[x] = StateF[S,x]})#l, Unit](
Put(s, Return[({type l[x] = StateF[S,x]})#l, Unit](())))
//> setState: [S](s: S)ch13.ex1.FreeState[S,Unit]
注意类型匹配。我们可以写个函数来运算这个FreeState：
def evalS[S,A](s: S, t: FreeState[S,A]): A = t.resume match {
case Right(a) => a
case Left(Get(f)) => evalS(s, f(s))
case Left(Put(n,a)) => evalS(n,a)
} //> evalS: [S, A](s: S, t: ch13.ex1.FreeState[S,A])A
这个运算方式还是调用了resume函数。注意：Get(f) 返回 StateF[S,A]，StateF是个Functor, F[Free[F,A]]那么A就是Free[F,A]
还是试试运算那个zipIndex函数：
def zipIndex[A](as: List[A]): List[(Int, A)] = {
evalS(1, as.foldLeft(unit[Int,List[(Int,A)]](List()))(
(acc,a) => for {
xs <- acc
n <- getState
_ <- setState(n+1)
} yield (n, a) :: xs)).reverse
} //> zipIndex: [A](as: List[A])List[(Int, A)]
zipIndex((0 to 10000).toList) //> res0: List[(Int, Int)] = List((1,0), (2,1), (3,2), (4,3), (5,4), (6,5), (7,
//| 6), (8,7), (9,8), (10,9), (11,10), (12,11), (13,12), (14,13), (15,14), (16,
//| 15), (17,16), (18,17), (19,18), (20,19), (21,20), (22,21), (23,22), (24,23)
没错，这段程序不但维护了一个状态而且使用了Trampoline运算模式，可以避免StackOverflow问题。
下面我们再用一个例子来示范Free Monad的Monadic Program和Interpreter各自的用途：
我们用一个Stack操作的例子。对Stack中元素的操作包括：Push,Add,Sub,Mul,End。这几项操作也可被视作一种Stack编程语言中的各项操作指令：
trait StackOps[A]
case class Push[A](value: Int, ops:A) extends StackOps[A]
case class Add[A](ops: A) extends StackOps[A]
case class Mul[A](ops: A) extends StackOps[A]
case class Dup[A](ops: A) extends StackOps[A]
case class End[A](ops: A) extends StackOps[A]
我们先推导它的Functor实例：
implicit val stackOpsFunctor: Functor[StackOps] = new Functor[StackOps] {
def map[A,B](oa: StackOps[A])(f: A => B): StackOps[B] = oa match {
case Push(v,a) => Push(v,f(a))
case Add(a) => Add(f(a))
case Mul(a) => Mul(f(a))
case Dup(a) => Dup(f(a))
case End(a) => End(f(a))
}
}
这里的next看起来是多余的，但它代表的是下一步运算。有了它才可能得到Functor实例，即使目前每一个操作都是完整独立步骤。
有了Functor实例我们就可以实现StackOps的Monadic programming:
def liftF[F[_],A](fa: F[A])(implicit F: Functor[F]): Free[F,A] = {
Suspend(F.map(fa)(a => Return(a)))
} //> liftF: [F[_], A](fa: F[A])(implicit F: ch13.ex1.Functor[F])ch13.ex1.Free[F,
//| A]
implicit def liftStackOps[A](sa: StackOps[A]): Free[StackOps,A] = liftF(sa)
//> liftStackOps: [A](sa: ch13.ex1.StackOps[A])ch13.ex1.Free[ch13.ex1.StackOps,
//| A]
val stkprg = for {
_ <- Push(1,())
_ <- Push(2,())
_ <- Add(())
} yield x //> stkprg : ch13.ex1.Free[ch13.ex1.StackOps,Unit] = Suspend(Push(1,Suspend(Pu
//| sh(2,Suspend(Add(Suspend(Pop(Return(())))))))))
我们用lisftStackOps函数把StackOps升格到Free[StackOps,A]后就可以用for-comprehension进行Monadic programming了。如果不习惯Add(())这样的表达式可以这样：
def push(value: Int) = Push(value,()) //> push: (value: Int)ch13.ex1.Push[Unit]
def add = Add(()) //> add: => ch13.ex1.Add[Unit]
def sub = Sub(()) //> sub: => ch13.ex1.Sub[Unit]
def mul = Mul(()) //> mul: => ch13.ex1.Mul[Unit]
def end = End(()) //> end: => ch13.ex1.End[Unit]
val stkprg = for {
_ <- push(1)
_ <- push(2)
_ <- add
_ <- push(4)
_ <- mul
} yield () //> stkprg : ch13.ex1.Free[ch13.ex1.StackOps,Unit] = Suspend(Push(1,Suspend(Pu
//| sh(2,Suspend(Add(Suspend(Push(4,Suspend(Mul(Return(())))))))))))
这样从文字意思上描述就清楚多了。但是，这个stkprg到底是干什么的？如果不从文字意义上解释我们根本不知道这段程序干了些什么，怎么干的。换句直白的话就是：没有意义。这正是Free Monad功能精妙之处：我们用Monad for-comprehension来编写一段Monadic program，然后在Interpreter中赋予它具体意义：用Interpreter来确定程序具体的意义。
那我们就进入Interpreter来运算这段程序吧。
先申明Stack类型： type Stack = List[Int]
在上面我们有个Interpreter, foldMap:
def foldMap[G[_]](f: F ~> G)(implicit F: Functor[F], G: Monad[G]): G[A] = resume match {
case Right(a) => G.unit(a)
case Left(k) => G.flatMap(f(k))(_ foldMap f)
}
但是运行stkprg必须传入Stack起始值，foldMap无法满足。那么我们再写另一个runner吧：
final def foldRun[B](b: B)(f: (B, F[Free[F,A]]) => (B, Free[F,A]))(implicit F: Functor[F]): (B, A) = {
@annotation.tailrec
def run(t: Free[F,A], z: B): (B, A) = t.resume match {
case Right(a) => (z, a)
case Left(k) => {
val (b1, f1) = f(z, k)
run(f1,b1)
}
}
run(this,b)
}
foldRun也是个折叠算法：给予一个起始值及一个对数据结构内部元素的处理函数然后可以开始运行。这个函数刚好符合我们的需要。下一步就是给予stkprg意义：确定Push,Add...这些指令具体到底干什么：
type Stack = List[Int]
def stackFn(stack: Stack, prg: StackOps[Free[StackOps,Unit]]): (Stack, Free[StackOps,Unit]) = prg match {
case Push(v, n) => {
(v :: stack, n)
}
case Add(n) => {
val hf :: hs :: t = stack
((hf + hs) :: stack, n)
}
case Sub(n) => {
val hf :: hs :: t = stack
((hs - hf) :: stack, n)
}
case Mul(n) => {
val hf :: hs :: t = stack
((hf * hs) :: stack, n)
}
} //> stackFn: (stack: ch13.ex1.Stack, prg: ch13.ex1.StackOps[ch13.ex1.Free[ch13.
//| ex1.StackOps,Unit]])(ch13.ex1.Stack, ch13.ex1.Free[ch13.ex1.StackOps,Unit])
啊。。。在这里我们才能具体了解每一句StackOps指令的意义。这就是Free Monad Interpreter的作用了。我们试着运算这个stkprg：
val stkprg = for {
_ <- push(1)
_ <- push(2)
_ <- add
_ <- push(4)
_ <- mul
} yield () //> stkprg : ch13.ex1.Free[ch13.ex1.StackOps,Unit] = Suspend(Push(1,Suspend(Pu
//| sh(2,Suspend(Add(Suspend(Push(4,Suspend(Mul(Return(())))))))))))
stkprg.foldRun(List[Int]())(stackFn) //> res0: (List[Int], Unit) = (List(12, 4, 3, 2, 1),())
跟踪一下操作步骤，最终结果是正确的。
我们再试一下用Natural Transformation原理的foldMap函数。我们可以用State的runS来传入Stack初始值：
type StackState[A] = State[Stack,A]
implicit val stackStateMonad = new Monad[StackState] {
def unit[A](a: A) = State(s => (a,s))
def flatMap[A,B](sa: StackState[A])(f: A => StackState[B]): StackState[B] = sa flatMap f
} //> stackStateMonad : ch13.ex1.Monad[ch13.ex1.StackState] = ch13.ex1$$anonfun$
//| main$1$$anon$5@26f67b76
这个StackState类型就是一个State类型。我们能够推导它的Monad实例，那我们就可以调用foldMap了。我们先编写Interpreter功能：
object StackOperator extends (StackOps ~> StackState) {
def apply[A](sa: StackOps[A]): StackState[A] = sa match {
case Push(v,n) => State((s: Stack) => (n, v :: s))
case Add(n) => State((s: Stack) => {
val hf :: hs :: t = s
(n, (hf + hs) :: s)
})
case Sub(n) => State((s: Stack) => {
val hf :: hs :: t = s
(n, (hs - hf) :: s)
})
case Mul(n) => State((s: Stack) => {
val hf :: hs :: t = s
(n, (hf * hs) :: s)
})
}
}
通过Natural Transformation把StackOps转成StackState状态维护。StackOps具体意义也在这里才能得到体验。我们用foldMap运算stkprg：
stkprg.foldMap(StackOperator).runS(List[Int]()) //> res1: (Unit, ch13.ex1.Stack) = ((),List(12, 4, 3, 2, 1))
我们得到了同样的运算结果。
希望通过这些例子能把Free Monad的用途、用法、原理解释清楚了。
泛函编程（31）－泛函IO：Free Monad－Running free的更多相关文章
- 泛函编程（5）－数据结构（Functional Data Structures)
编程即是编制对数据进行运算的过程.特殊的运算必须用特定的数据结构来支持有效运算.如果没有数据结构的支持,我们就只能为每条数据申明一个内存地址了,然后使用这些地址来操作这些数据,也就是我们熟悉的申明变量 ...
- 泛函编程（32）－泛函IO：IO Monad
由于泛函编程非常重视函数组合(function composition),任何带有副作用(side effect)的函数都无法实现函数组合,所以必须把包含外界影响(effectful)副作用不纯代码( ...
- 泛函编程（30）－泛函IO：Free Monad－Monad生产线
在上节我们介绍了Trampoline.它主要是为了解决堆栈溢出(StackOverflow)错误而设计的.Trampoline类型是一种数据结构,它的设计思路是以heap换stack:对应传统递归算法 ...
- 泛函编程（27）－泛函编程模式－Monad Transformer
经过了一段时间的学习,我们了解了一系列泛函数据类型.我们知道,在所有编程语言中,数据类型是支持软件编程的基础.同样,泛函数据类型Foldable,Monoid,Functor,Applicative, ...
- 泛函编程（24）－泛函数据类型－Monad, monadic programming
在上一节我们介绍了Monad.我们知道Monad是一个高度概括的抽象模型.好像创造Monad的目的是为了抽取各种数据类型的共性组件函数汇集成一套组件库从而避免重复编码.这些能对什么是Monad提供一个 ...
- 泛函编程（38）－泛函Stream IO：IO Process in action
在前面的几节讨论里我们终于得出了一个概括又通用的IO Process类型Process[F[_],O].这个类型同时可以代表数据源(Source)和数据终端(Sink).在这节讨论里我们将针对Proc ...
- 泛函编程（36）－泛函Stream IO：IO数据源－IO Source & Sink
上期我们讨论了IO处理过程:Process[I,O].我们说Process就像电视信号盒子一样有输入端和输出端两头.Process之间可以用一个Process的输出端与另一个Process的输入端连接 ...
- 泛函编程（35）－泛函Stream IO：IO处理过程－IO Process
IO处理可以说是计算机技术的核心.不是吗?使用计算机的目的就是希望它对输入数据进行运算后向我们输出计算结果.所谓Stream IO简单来说就是对一串按序相同类型的输入数据进行处理后输出计算结果.输入数 ...
- 泛函编程（34）－泛函变量：处理状态转变－ST Monad
泛函编程的核心模式就是函数组合(compositionality).实现函数组合的必要条件之一就是参与组合的各方程序都必须是纯代码的(pure code).所谓纯代码就是程序中的所有表达式都必须是Re ...
- 泛函编程（28）－粗俗浅解：Functor, Applicative, Monad
经过了一段时间的泛函编程讨论,始终没能实实在在的明确到底泛函编程有什么区别和特点:我是指在现实编程的情况下所谓的泛函编程到底如何特别.我们已经习惯了传统的行令式编程(imperative progra ...
随机推荐
- Atitit paip.对象方法的实现原理与本质.txt
Atitit paip.对象方法的实现原理与本质.txt 对象方法是如何实现的1 数组,对象,字典1 对象方法是如何实现的 这显然是一个对象方法调用.但对象方法是如何实现的呢?在静态语言中,因为有编译 ...
- Drupal网站开发实践－－自定义购物流程
由于Commerce模块自带的购物流程步骤过多,界面不太美观,所以需要重新设计. 改造后的购物流程分成两部:购物车->结算,就两个页面.购物车页面可以修改商品的数量,删除购物车内商品,查看总金额 ...
- Drupal网站开发实践系列
这一系列文章会记录我最近一个项目的开发历程.包括用到的模块,功能的具体实现,调用的API,还有主题的制作,一部分前端信息等. 该网站基于Drupal7+Commerce制作,主题部分基本完全自定义,没 ...
- iOS-国家气象局-天气预报接口等常用接口
接口地址: http://www.weather.com.cn/data/sk/101010100.html http://www.weather.com.cn/data/cityinfo/10101 ...
- C#、.Net代码精简优化(空操作符（??）、as、string.IsNullOrEmpty() 、 string.IsNullOrWhiteSpace()、string.Equals()、System.IO.Path 的用法)
一.空操作符(??)在程序中经常会遇到对字符串或是对象判断null的操作,如果为null则给空值或是一个指定的值.通常我们会这样来处理: .string name = value; if (name ...
- 每天一个linux命令（22）：find 命令的参数详解
find一些常用参数的一些常用实例和一些具体用法和注意事项. 1．使用name选项: 文件名选项是find命令最常用的选项,要么单独使用该选项,要么和其他选项一起使用. 可以使用某种文件名模式来匹配 ...
- C# string.format、string.connect和+=运算 效率计算
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Stri ...
- Java集合-5. （List）已知有一个Worker 类如下： 完成下面的要求 1) 创建一个List，在List 中增加三个工人，基本信息如下： 姓名 年龄 工资 zhang3 18 3000 li4 25 3500 wang5 22 3200 2) 在li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资3300 3) 删除wang5 的信息 4) 利用for 循
第六题 5. (List)已知有一个Worker 类如下: public class Worker { private int age; private String name; private do ...
- JSP网站开发基础总结《一》
经过JAVASE的学习相信大家对JAVA已经不再陌生,那么JAVA都可以干什么呢?做算法.应用程序.网站开发都可以,从今天开始为大家奉上JAVAEE之JSP动态网站开发基础总结. 既然是动态网站开发, ...
- 【Android】Android Camera原始帧格式转换 —— 获取Camera图像（一）
概述: 做过Android Camera图像采集和处理的朋友们应该都知道,Android手机相机采集的原始帧(RawFrame)默认是横屏格式的,而官方API有没有提供一个设置Camera采集图像的 ...