Scalaz（10）－ Monad：就是一种函数式编程模式－a design pattern详解编程语言

Monad typeclass不是一种类型，而是一种程序设计模式（design pattern），是泛函编程中最重要的编程概念，因而很多行内人把FP又称为Monadic Programming。这其中透露的Monad重要性则不言而喻。Scalaz是通过Monad typeclass为数据运算的程序提供了一套规范的编程方式，如常见的for-comprehension。而不同类型的Monad实例则会支持不同的程序运算行为，如：Option Monad在运算中如果遇到None值则会中途退出；State Monad会确保状态值会伴随着程序运行流程直到终结；List Monad运算可能会产生多个结果等等。Scalaz提供了很多不同种类的Monad如：StateMonad, IOMonad, ReaderMonad, WriterMonad，MonadTransformer等等，这从另一个角度也重申了Monad概念在泛函编程里的重要性。听起来以上这些描述好像有点摸不着头脑，可能应该把它们放在本篇最终总结，不过我还是想让大家有个大的概念。对下面的讨论细节的理解能有所帮助。我们还是从Monad trait开始介绍吧：

 1 trait Monad[F[_]] extends Applicative[F] with Bind[F] { self => 
 2   //// scalaz/Monad.scala 
 3  
 4   override def map[A,B](fa: F[A])(f: A => B) = bind(fa)(a => point(f(a))) 
 5 ... 
 6 trait Applicative[F[_]] extends Apply[F] { self => 
 7   //// scalaz/Applicative.scala 
 8   def point[A](a: => A): F[A] 
 9 ... 
10 trait Apply[F[_]] extends Functor[F] { self => 
11   //// scalaz/Apply.scala 
12   def ap[A,B](fa: => F[A])(f: => F[A => B]): F[B] 
13 ... 
14 trait Bind[F[_]] extends Apply[F] { self => 
15   //// scalaz/Bind.scala 
16  
17   /** Equivalent to `join(map(fa)(f))`. */ 
18   def bind[A, B](fa: F[A])(f: A => F[B]): F[B] 
19  
20   override def ap[A, B](fa: => F[A])(f: => F[A => B]): F[B] = { 
21     lazy val fa0 = fa 
22     bind(f)(map(fa0)) 
23   } 
24 ...

上面这些类型trait的继承关系是这样的：Monad继承了Applicative和Bind，Applicative继承了Apply, Apply继承了Functor, Bind也继承了Apply。所以Monad同时又是Applicative和Functor，因为Monad实现了map和ap函数。一个Monad实例可以调用所有Applicative和Functor提供的组件函数。任何实例只需要实现抽象函数point和bind就可以成为Monad实例，然后就可以使用Monad所有的组件函数了。

Monad所提供的主要注入方法（injected method）是在BindOps和MonadOps里。在BindOps里主要提供了flatMap: scalaz/syntax/BindSyntax.scala

 1 final class BindOps[F[_],A] private[syntax](val self: F[A])(implicit val F: Bind[F]) extends Ops[F[A]] { 
 2   //// 
 3   import Liskov.<~<, Leibniz.=== 
 4  
 5   def flatMap[B](f: A => F[B]) = F.bind(self)(f) 
 6  
 7   def >>=[B](f: A => F[B]) = F.bind(self)(f) 
 8  
 9   def ∗[B](f: A => F[B]) = F.bind(self)(f) 
10 ...

主要是这个flatMap函数，在scalaz里用>>=来表示。这是一个大家都起码耳熟的函数：好像flatMap就代表了Monad。在MonadOps里提供的注入方法如下：scalaz/Syntax/MonadSyntax.scala

 1 final class MonadOps[F[_],A] private[syntax](val self: F[A])(implicit val F: Monad[F]) extends Ops[F[A]] { 
 2   //// 
 3  
 4   def liftM[G[_[_], _]](implicit G: MonadTrans[G]): G[F, A] = G.liftM(self) 
 5  
 6   def whileM[G[_]](p: F[Boolean])(implicit G: MonadPlus[G]): F[G[A]] = F.whileM(p, self) 
 7  
 8   def whileM_(p: F[Boolean]): F[Unit] = F.whileM_(p, self) 
 9  
10   def untilM[G[_]](p: => F[Boolean])(implicit G: MonadPlus[G]): F[G[A]] = F.untilM(self, p) 
11  
12   def untilM_(p: => F[Boolean]): F[Unit] = F.untilM_(self, p) 
13  
14   def iterateWhile(p: A => Boolean): F[A] = F.iterateWhile(self)(p) 
15  
16   def iterateUntil(p: A => Boolean): F[A] = F.iterateUntil(self)(p) 
17  
18   //// 
19 }

看起来这些注入方法都是一些编程语言里的流程控制语法（control flow syntax）。这是不是暗示着Monad最终会实现某种编程语言？我们把这些函数的使用方法放在后面的一些讨论去。我们先来分析一下flatMap函数，因为这是个Monad代表函数。下面是Functor,Applicative和Monad施用函数格式比较：

1 // Functor    :  map[A,B]    (F[A])(f:   A => B):  F[B] 
2 // Applicative:  ap[A,B]     (F[A])(f: F[A => B]): F[B]  
3 // Monad      :  flatMap[A,B](F[A])(f: A => F[B]): F[B]

以上三种函数款式基本上是一致的。大家都说这就是三种FP的函数施用方式：在一个容器内进行函数的运算后把结果还留在容器内、得到的效果是这样的：F[A] => F[B]。只是它们分别用不同的方式提供这个施用的函数。Functor的map提供了普通函数，Applicative通过容器提供了施用函数ap而Monad则是通过直接函数施用方式来实现F[A] => F[B]: 直接对输入A进行函数施用并产生一个F[B]结果。Monad的这种方式应该不是严格意义上的在容器内进行函数施用。从另一个角度分析，Monad可以被视作某种算法(computation)。Monad F[A]代表了对一个A类型数据的算法(computation)。如果这样说那么Monad就有了全新的解释：Monad就是一种可以对某种类型的数据值进行连续计算的算法(computation)：如果我们把flatMap串联起来的话就会是这样的：

1 //   fa.flatMap(a => fb.flatMap(b => fc.flatMap(c => fd.map(...))))

在这里fa,fb,fc都是F[T]这样的算法。可以看出当我们把flatMap串接起来后就形成了一个串型（sequencial）流程（workflow）的F[]算法。为了更清楚的了解串接flatMap的意义，我们用同等的for-comprehension来示范：

1 //   for { 
2 //      a <- (fa: F[A]) 
3 //      b <- (fb: F[A]) 
4 //      c <- (fc: F[A]) 
5 //   } yield { ... }

这样表达会更加清晰了：我们先运算fa，得到结果a后接着运算fb,得出结果b后再运算fc，得出结果c … 这像是一段行令程序（imperative program）。我们再用个形象点的例子来示范说明：

 1 class Foo { def bar: Option[Bar] } 
 2 class Bar { def baz: Option[Baz] } 
 3 class Bar { def baz: Option[Baz] } 
 4  
 5 def compute(maybeFoo: Option[Foo]): Option[Int] = 
 6  maybeFoo.flatMap { foo => 
 7   foo.bar.flatMap { bar => 
 8     bar.baz.map { baz => 
 9       baz.compute 
10     } 
11   } 
12  } 
13 def compute2(maybeFoo: Option[Foo]): Option[Int] = 
14   for { 
15       foo <- maybeFoo 
16       bar <- foo.bar 
17       baz <- bar.baz 
18   }  yield baz.compute

可以看出，每一个算法都依赖前面算法得出的结果。从这个例子我们可以得出Monad的串型运算（sequencial computation）特性。确切来说，flatMap并不适合并行运算，所以我们需要Applicative。这是因为Applicative是在既有的容器中运算，而flatMap则会重新创建新的容器（在Monad的世界里容器即为算法（computation）。但是因为我们讲过Monad就是Applicative，所以Monad也可以实现并行运算。Applicative 的 ap 函数可以用 flatMap实现：

1 // ap[A,B](ma: F[A])(mf: F[A => B]): F[B] = mf.flatMap(f => ma.flatMap(a => point(f(a)))

也可以用flatMap来实现Functor的map函数：

1 // map[A,B](fa: F[A])(f: A => B): F[B] = fa.flatMap(a => point(f(a)))

从上面的例子好像可以领悟一些关于FP即Monadic Programming的说法。形象的来讲：这个所谓的算法Monad F[]就好像是在F[]这么个壳子里进行传统编程：还记着的话，FP编程既是纯函数（pure function）对F[T]里的T值进行运算，没有中间变量（temp variable）,没有副作用（no side-effect）。但现在有了Monad，我们就可以使用传统的行令编程（imperative programming）了。再形象一点来说上面的for loop就像F[]壳子，在for loop内可以进行申明变量，更新状态等OOP式行令编程。但这些变化（mutability）不会漏出for loop之外。不过，本篇所述Monad编程的单一局限性还是很明显的：因为在for loop 内部的操作函数都必须返回同一种类型的Monad实例如：Option[], List[]，SomeType[]等等。而且程序运算行为只会受一种类型的特性所控制。如上面所叙，Monad实例的类型控制Monadic程序的运算行为。每一种Monad实例的程序可以有不同的运算方式。如果需要多种类型行为的Monad程序，就需要使用Monad Transformer typeclass了。这个在将来的讨论中自会提及，现在好像说的过头了。我们还是回到Monad的基本操作。

Option是scala标准库的一个类型。它已经是个Monad，所以可以使用flatMap：

1 2.some flatMap {x => (x + 3).some }               //> res0: Option[Int] = Some(5) 
2 2.some >>= { x => (x + 3).some }                  //> res1: Option[Int] = Some(5) 
3 (none: Option[Int]) >>= {x => (x + 3).some }      //> res2: Option[Int] = None

我们可以用Monad[T] point来把一个普通值A升格到T[A]：

1 Monad[Option].point(2)                            //> res3: Option[Int] = Some(2) 
2 Monad[Option].point(2) >>= {x => Monad[Option].point(x + 3)} 
3                                                   //> res4: Option[Int] = Some(5) 
4 (None: Option[Int]) >>= {x => Monad[Option].point(x + 3)} 
5                                                   //> res5: Option[Int] = None

在上面的例子里我们不断提及Option Monad是有原因的，因为Option类型的Monad典型实例，在控制运算流程时最有特点：可以在中途退出，在遇到None值时可以立即终止运算。

我们用一个比较现实点的例子来示范：我正尝试用自己的方式来练习举重 – 我最多能举起50KG、每个杠铃片重2.5公斤、杠铃两端不必平衡，但一边不得超过另一边多于3个杠铃片（多3个还没问题）。试着用一个自定义类型来模拟举重：

1 type Discs = Int  //杠铃片数量 
2 case class Barbell(left: Discs, right: Discs) { 
3     def loadLeft(n: Discs): Barbell = copy(left = left + n) 
4     def loadRight(n: Discs): Barbell = copy(right = right + n) 
5 } 
6 Barbell(0,0).loadLeft(1)                          //> res8: Exercises.monad.Barbell = Barbell(1,0) 
7 Barbell(1,0).loadRight(1)                         //> res9: Exercises.monad.Barbell = Barbell(1,1) 
8 Barbell(2,1).loadLeft(-1)                         //> res10: Exercises.monad.Barbell = Barbell(1,1)

现在这个自定义类型Barbell是可以跟踪当前杠铃左右重量状态的。现在我把往杠铃上增加重量片的过程串联起来：

1 Barbell(0,0).loadLeft(1).loadRight(2).loadRight(100).loadLeft(2).loadRight(-99) 
2                                                   //> res11: Exercises.monad.Barbell = Barbell(3,3)

可以看到这个过程中有些环节已经超出了我的能力，但杠铃最终状态好像还是合理的。我们需要在重量配置不合理的时候就立即终止。现在我们可以用Option来实现这项功能：

 1 type Discs = Int  //杠铃片数量 
 2 case class Barbell(left: Discs, right: Discs) { 
 3   def loadLeft(n: Discs): Option[Barbell] = copy(left = left + n) match { 
 4     case Barbell(left,right) => if ( (left+right <= 20) && math.abs(left-right) <=3 ) Some(Barbell(left,right)) else None 
 5     case _ => None 
 6   } 
 7   def loadRight(n: Discs): Option[Barbell] = copy(right = right + n) match { 
 8     case Barbell(left,right) => if ( (left+right <= 20) && math.abs(left-right) <=3 ) Some(Barbell(left,right)) else None 
 9     case _ => None 
10   } 
11 } 
12 Barbell(0,0).loadLeft(1)                          //> res8: Option[Exercises.monad.Barbell] = Some(Barbell(1,0)) 
13 Barbell(1,0).loadRight(1)                         //> res9: Option[Exercises.monad.Barbell] = Some(Barbell(1,1)) 
14 Barbell(2,1).loadLeft(-1)                         //> res10: Option[Exercises.monad.Barbell] = Some(Barbell(1,1)) 
15 Barbell(0,0).loadLeft(4)                          //> res11: Option[Exercises.monad.Barbell] = None 
16 Barbell(15,1).loadRight(15)                       //> res12: Option[Exercises.monad.Barbell] = None

超出重量平衡的情况返回了None。现在返回值是个Option，而Option是个Monad，所以我们可以用flatMap把每个环节串联起来：

1 Barbell(0,0).loadLeft(3) >>= {_.loadRight(3)}     //> res13: Option[Exercises.monad.Barbell] = Some(Barbell(3,3)) 
2 Barbell(0,0).loadLeft(3) >>= {_.loadRight(3) >>= {_.loadRight(1)}} 
3                                                   //> res14: Option[Exercises.monad.Barbell] = Some(Barbell(3,4)) 
4 Barbell(0,0).loadLeft(3) >>= {_.loadRight(3) >>= {_.loadRight(1) >>= {_.loadLeft(4)}}} 
5                                                   //> res15: Option[Exercises.monad.Barbell] = Some(Barbell(7,4)) 
6 Barbell(0,0).loadLeft(1) >>= {_.loadRight(5) >>= {_.loadLeft(2)}} 
7                                                   //> res16: Option[Exercises.monad.Barbell] = None 
8 Monad[Option].point(Barbell(0,0)) >>= {_.loadLeft(3) >>= {_.loadRight(6)}} 
9                                                   //> res17: Option[Exercises.monad.Barbell] = Some(Barbell(3,6))

我们的最终目的是用for-comprehension来表述，会更加清晰：

 1 def addWeight: Option[Barbell] = for { 
 2     b0 <- Monad[Option].point(Barbell(0,0)) 
 3     b1 <- b0.loadLeft(3) 
 4     b2 <- b1.loadRight(3) 
 5 } yield b2                                        //> addWeight: => Option[Exercises.monad.Barbell] 
 6 addWeight                                         //> res18: Option[Exercises.monad.Barbell] = Some(Barbell(3,3)) 
 7  
 8 def addWeight1: Option[Barbell] = for { 
 9     b0 <- Monad[Option].point(Barbell(0,0)) 
10     b1 <- b0.loadLeft(4) 
11     b2 <- b1.loadRight(3) 
12 } yield b2                                        //> addWeight1: => Option[Exercises.monad.Barbell] 
13 addWeight1                                        //> res19: Option[Exercises.monad.Barbell] = None

从以上的例子可以得出：实现了一个数据类型的Monad实例后就可以获取以这个类型控制运算行为的一种简单的编程语言，这种编程语言可以在for loop内部实现传统的行令编程风格。

在本篇讨论中我们介绍了Monad实际上是一种编程模式，并且示范了简单的for loop内部流程运算。在下面的一系列讨论中我们将会了解更多类型的Monad，以及Monad如何能成为功能完善的编程语言。

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12937.html

Scalaz（10）－ Monad：就是一种函数式编程模式－a design pattern详解编程语言

相关推荐

发表回复