Scalaz（18）－ Monad： ReaderWriterState-可以是一种简单的编程语言 - Scala

TOP

Scalaz（18）－ Monad： ReaderWriterState-可以是一种简单的编程语言(二)

2017-10-10 12:13:28 【大中小】浏览:4921次

Tags：Scalaz Monad ReaderWriterState- 可以简单编程语言

[S,A](run: S => Option[(S,A)]) { def map[B](f: A => B): OptionState[S,B] = OptionState { s => run(s) map { case (s1,a1) => (s1,f(a1)) } } def flatMap[B](f: A => OptionState[S,B]): OptionState[S,B] = OptionState { s => run(s) flatMap { case (s1,a1) => f(a1).run(s1) } } }

是的，我们可以用Option的map和flatMap来实现OptionState的map和flatMap。当然，如果我们想在一个for-comprehension里同时使用Option和State就必须把它们升格成OptionState类型：

 def liftOption[S,A](oa: Option[A]): OptionState[S,A] = oa match { case Some(a) => OptionState {s => (s,a).some } case None => OptionState {_ => none} } def liftState[S,A](sa: State[S,A]): OptionState[S,A] = OptionState {s => sa(s).some}

现在试试用叠加效果的for-comprehension：

 1 val osprg: OptionState[Int,Int] = for {  2    a <- liftOption(3.some)  3    b <- liftState(put(a))  4    c <- liftState(get[Int])  5    d <- liftState(State[Int,Int](s => (s+c, s+a)))  6  } yield c                                        //> osprg : Exercises.rws.OptionState[Int,Int] = OptionState(<function1>)
 7  osprg.run(2)                                     //> res3: Option[(Int, Int)] = Some((6,3))
 8  val osprg1: OptionState[Int,Int] = for {  9    a <- liftOption(3.some) 10    b <- liftState(put(a)) 11    _ <- liftOption((None: Option[Int])) 12    c <- liftState(get[Int]) 13    d <- liftState(State[Int,Int](s => (s+c, s+a))) 14  } yield c                                        //> osprg1 : Exercises.rws.OptionState[Int,Int] = OptionState(<function1>)
15  osprg1.run(2)                                    //> res4: Option[(Int, Int)] = None

看，既可以维护状态又具备None处理机制。

好了，scalaz里有个ReaderWriterState这么个type class，就是一个Reader+Writer+State堆砌的Monad。相信scalaz特别提供了这么个type class应该有它的用意。我的猜想是这个Monad是个功能比较完整的组合Monad。作为for-comprehension的context应该能提供比较全面的效果。从字意上解释就是在由它形成的Monadic编程语言里可以同时提供运算（compute）、跟踪(logging)和状态维护功能。它的基础类型是IndexedReaderWriterStateT：scalaz/package.scala

  type ReaderWriterStateT[F[_], -R, W, S, A] = IndexedReaderWriterStateT[F, R, W, S, S, A] object ReaderWriterStateT extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions { def apply[F[_], R, W, S, A](f: (R, S) => F[(W, A, S)]): ReaderWriterStateT[F, R, W, S, A] = IndexedReaderWriterStateT[F, R, W, S, S, A] { (r: R, s: S) => f(r, s) } } type IndexedReaderWriterState[-R, W, -S1, S2, A] = IndexedReaderWriterStateT[Id, R, W, S1, S2, A] object IndexedReaderWriterState extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions { def apply[R, W, S1, S2, A](f: (R, S1) => (W, A, S2)): IndexedReaderWriterState[R, W, S1, S2, A] = IndexedReaderWriterStateT[Id, R, W, S1, S2, A] { (r: R, s: S1) => f(r, s) } } type ReaderWriterState[-R, W, S, A] = ReaderWriterStateT[Id, R, W, S, A] object ReaderWriterState extends ReaderWriterStateTInstances with ReaderWriterStateTFunctions { def apply[R, W, S, A](f: (R, S) => (W, A, S)): ReaderWriterState[R, W, S, A] = IndexedReaderWriterStateT[Id, R, W, S, S, A] { (r: R, s: S) => f(r, s) } } type IRWST[F[_], -R, W, -S1, S2, A] = IndexedReaderWriterStateT[F, R, W, S1, S2, A] val IRWST: IndexedReaderWriterStateT.type = IndexedReaderWriterStateT type IRWS[-R, W, -S1, S2, A] = IndexedReaderWriterState[R, W, S1, S2, A] val IRWS: IndexedReaderWriterState.type = IndexedReaderWriterState type RWST[F[_], -R, W, S, A] = ReaderWriterStateT[F, R, W, S, A] val RWST: ReaderWriterStateT.type = ReaderWriterStateT type RWS[-R, W, S, A] = ReaderWriterState[R, W, S, A] val RWS: ReaderWriterState.type = ReaderWriterState

如果把Reader,Writer,State款式分开来对比分析的话：

case class Reader[R, A

首页上一页 1 2 3 4 5 下一页尾页 2/5/5
【大中小】【打印】【繁体】【投稿】【收藏】【推荐】【举报】【评论】【关闭】【返回顶部】

上一篇：Scalaz（17）－ Monad：泛函状态..	下一篇：Scalaz（19）－ Monad： \/ - Mon..