scala - 使用状态 Monad 链接多个转换

Question

我开始使用状态 monad 来清理我的代码。我已经解决了我的问题，我处理了一个名为 CDR 的事务并相应地修改了状态。
使用此函数来执行状态更新，它对于单个事务工作得非常好。

def addTraffic(cdr: CDR): Network => Network = ...

下面是一个例子:

scala> val processed: (CDR) => State[Network, Long] = cdr =>
 |   for {
 |     m <- init
 |     _ <- modify(Network.addTraffic(cdr))
 |     p <- get
 |   } yield p.count
processed: CDR => scalaz.State[Network,Long] = $$Lambda$4372/1833836780@1258d5c0

scala> val r = processed(("122","celda 1", 3))
r: scalaz.State[Network,Long] = scalaz.IndexedStateT$$anon$13@4cc4bdde

scala> r.run(Network.empty)
res56: scalaz.Id.Id[(Network, Long)] = (Network(Map(122 -> (1,0.0)),Map(celda 1 -> (1,0.0)),Map(1 -> Map(1 -> 3)),1,true),1)

我现在想做的是在迭代器上链接一些事务。我发现了一些效果很好的东西，但是状态转换不需要输入(通过 RNG 进行状态更改)

  import scalaz._
  import scalaz.std.list.listInstance
  type RNG = scala.util.Random

  val f = (rng:RNG) => (rng, rng.nextInt)
  val intGenerator: State[RNG, Int] = State(f)
  val rng42 = new scala.util.Random
  val applicative = Applicative[({type l[Int] = State[RNG,Int]})#l]

  // To generate the first 5 Random integers
  val chain: State[RNG, List[Int]] = applicative.sequence(List.fill(5)(intGenerator))
  val chainResult: (RNG, List[Int]) = chain.run(rng42)
  chainResult._2.foreach(println)

我尝试调整此方法失败，但我无法让他们输入匹配的签名，因为我的状态函数需要 cdr(事务)输入

谢谢

Answer 1

TL;博士
您可以使用 traverse来自 Traverse List 的集合(例如 CDR )上的类型类s，使用具有此签名的函数:CDR => State[Network, Long] .结果将是 State[Network, List[Long]] .或者，如果您不关心 List[Long]在那里，您可以使用 traverse_相反，它将返回 State[Network, Unit] .最后，是否要“聚合”结果 T随着他们的到来，T形成一个 Monoid ，您可以使用 foldMap来自 Foldable ，这将返回 State[Network, T] ，其中 T是所有 T 的组合(例如折叠)结果s 在你的链中。

代码示例
现在有更多细节，以及代码示例。我将使用 Cats State 回答这个问题而不是 Scalaz，因为我从未使用过后者，但概念是相同的，如果您仍然有问题，我会挖掘出正确的语法。

假设我们有以下数据类型和导入要使用:

import cats.implicits._
import cats.data.State

case class Position(x : Int = 0, y : Int = 0)

sealed trait Move extends Product
case object Up extends Move
case object Down extends Move
case object Left extends Move
case object Right extends Move

很明显， Position表示二维平面中的一个点和一个 Move可以向上、向下、向左或向右移动这样的点。

现在，让我们创建一个方法，让我们可以看到我们在给定时间的位置:

def whereAmI : State[Position, String] = State.inspect{ s => s.toString }

以及改变我们位置的方法，给定 Move :

def move(m : Move) : State[Position, String] = State{ s => 
  m match {
    case Up => (s.copy(y = s.y + 1), "Up!")
    case Down => (s.copy(y = s.y - 1), "Down!")
    case Left => (s.copy(x = s.x - 1), "Left!")
    case Right => (s.copy(x = s.x + 1), "Right!")
  }
}

请注意，这将返回 String , 移动名称后跟一个感叹号。这只是为了模拟 Move 的类型变化到别的东西，并显示结果将如何聚合。稍后会详细介绍这一点。

现在让我们尝试使用我们的方法:

val positions : State[Position, List[String]] = for{
  pos1 <- whereAmI 
  _ <- move(Up)
  _ <- move(Right)
  _ <- move(Up)
  pos2 <- whereAmI
  _ <- move(Left)
  _ <- move(Left)
  pos3 <- whereAmI
} yield List(pos1,pos2,pos3)

我们可以给它一个初始 Position并查看结果:

positions.runA(Position()).value // List(Position(0,0), Position(1,2), Position(-1,2))

(你可以忽略这里的 .value，这是一个怪癖，因为 State[S,A] 实际上只是 StateT[Eval,S,A] 的别名)

如您所见，这与您期望的一样，您可以创建不同的“蓝图”(例如状态修改序列)，一旦提供初始状态，这些蓝图就会被应用。

现在，要真正回答你的问题，假设我们有一个 List[Move]我们希望将它们依次应用于初始状态，并得到结果:我们使用 traverse来自 Traverse type-class .

val moves = List(Down, Down, Left, Up)
val result : State[Position, List[String]] = moves.traverse(move)
result.run(Position()).value // (Position(-1,-1),List(Down!, Down!, Left!, Up!))

或者，如果您不需要 A完全(在你的情况下是 List)，你可以使用 traverse_ , 而不是 traverse结果类型将是:

val result_ : State[Position, List[String]] = moves.traverse_(move)
result_.run(Position()).value // (Position(-1,-1),Unit)

最后，如果您的 A输入 State[S,A]形成一个 Monoid ，那么你也可以使用 foldMap来自 Foldable合并(例如折叠)所有 A s，因为它们是计算出来的。一个简单的例子(可能没用，因为这只会连接所有 String s)是这样的:

val result : State[Position,String] = moves.foldMap(move)
result.run(Position()).value // (Position(-1,-1),Down!Down!Left!Up!)

最后一种方法对您是否有用，实际上取决于 A你有，如果把它结合起来有意义。

这应该是你在你的场景中所需要的。