Scalaz（31）－ Free ：自由数据结构－算式和算法的关注分离

   咱们能够经过自由数据结构（Free Structure）实现对程序的算式和算法分离关注（separation of concern）。算式（Abstract Syntax Tree, AST）即运算表达式，是对程序功能的描述。算法则是程序的具体运算方式（Interpreter）,它赋予了算式意义。下面咱们先用一个例子简单解释何为算式、算法：

用一个简单的表达式 1+2+3，这个表达式同时包含了算式和算法：运算表达式是 a Op b Op c, 算法是：Int加法，a,b,c为Int, oP为Int+。那么咱们可不可把它分解成算式和算法呢？咱们能够先把算式推导出来：Op(a,Op(b,c))。咱们能够在算法里对Op即a,b,c进行多种定义，即经过这些定义咱们能赋予算式不一样的意义。这个例子能够形象的描述算式、算法关注分离的全过程：抽象描述咱们要运算的程序，定义具体运算方式能够分开进行。

实际上 1+2+3能够说是一种Monoid操做。咱们看看是否能从中推导出Free Monoid，一个Monoid自由数据结构用来实现Monoidal操做的算式、算法分离关注。针对任意基本类型A的Monoid定义以下：

一、一个二元函数 append: (A,A)=>A

二、一个A类型的初始值（零值）zero

Monoid必须遵循如下定律：

一、append函数的关联性associativity: 对任意A类型的x,y,z - append(x,append(y,z)) === append(append(x,y),z)

二、zero的同一概identity law: 对任意类型的x - append(zero,x) === append(x,zero)

根据以上定律，上面的表达式 1+2+3 === 1+(2+(3+0))。它的算式能够是这样：append(x,append(y,append(z,zero)))。那么咱们应该能够获得这样的Free Monoid自由数据结构：

1 sealed trait FreeMonoid[+A] 2 final case object Zero extends FreeMonoid[Nothing] 3 final case class Append[A](l: A, r: FreeMonoid[A]) extends FreeMonoid[A]

1::2::3::Nil >>> List(1,2,3)，若是A是个Monoid那么List[A]也是个Monoid，List[A]是个Free Monoid自由数据结构，咱们看下面的示范：

1 def listOp[A](l: List[A]): FreeMonoid[A] = l match { 2     case Nil => Zero 3     case h :: t => Append(h,listOp(t)) 4 }                                                 //> listOp: [A](l: List[A])Exercises.freestruct.FreeMonoid[A]
5 listOp(List(1,2,3))                               //> res0: Exercises.freestruct.FreeMonoid[Int] = Append(1,Append(2,Append(3,Zero 6                                                   //| )))

List是一个Free Monoid, 它的 Nil === Zero,  a ++ b === Append(a,b)。

一样，咱们能够从Monad的特性操做函数来推导Free Monad自由数据结构。咱们能够用如下操做函数来构建一个Monad M[_]：

一、point: A => M[A]

二、join: M[M[A]] => M[A]

三、map: (M[A], A => B) => M[B]

（point+flatMap组合一样能构建Monad）

Free Monad是基于类型构建器Functor F[_]的Free Monoid, 因此Free Monad的定义应该是这样的：

sealed trait Free[F[_],A]

咱们能够直接把point转换成case class:

final case class Return[F[_],A](a: A) extends Free[F,A] 

join的输入类型是F[F[A]]，咱们须要把Free[F,A]放在内里：

final case class Suspend[F[_],A](ffa: F[Free[F,A]) extends Free[F,A]

咱们如今能够猜想Free Monad的自由数据结构定义以下：

1 sealed trait Free[F[_], A] 2 final case class Return[F[_],A](a: A) extends Free[F,A] 3 final case class Suspend[F[_],A](ffa: F[Free[F,A]]) extends Free[F,A]

咱们只需证实用以上结构能够实现Monad的全部特性操做函数，那么这个Free就是一个用Functor F产生Monad的Monad构造器，一个最简单结构的Monad构造器，即Free Monad：

 1 import scalaz.Functor  2 final case class Return[F[_],A](a: A) extends Free[F,A]  3 final case class Suspend[F[_],A](ffa: F[Free[F,A]]) extends Free[F,A]  4 sealed trait Free[F[_],A] {  5   def point(a: A) = Return[F,A](a)  6   def flatMap[B](f: A => Free[F,B])(implicit F: Functor[F]): Free[F,B] =
 7     this match {  8       case Return(a) => f(a)  9       case Suspend(ffa) => Suspend[F,B](F.map(ffa)(fa => fa flatMap f)) 10  } 11   def map[B](f: A => B): Free[F,B] = flatMap(a => Return[F,B](f(a))) 12   def join(ffa: F[Free[F,A]]): Free[F,A] = Suspend[F,A](ffa) 13 
14 }

这个Free自由数据结构足够支持咱们实现point,flatMap,map,join这几个Monad特性操做函数，因此Free是个Free Monad。

若是Free是个Free Monad，咱们能够把Free[F,A]里的F[A]当作Program[Commands]。即咱们能够用命令集Commands来独立描述程序Program。最终的程序Program是不会产生反作用的，因此允许最大限度的函数组合（function composition）。对Program的具体运算方法则能够独立分开实现。咱们将在下次讨论中着重介绍Free Monad的实际应用方式：AST和Interpreter的实现过程。