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; DR
您可以使用具有以下签名的函数：traverse在Traverse的集合（例如List）上使用CDR类型类中的CDR => State[Network, Long]。结果将为State[Network, List[Long]]。另外，如果您不关心那里的List[Long]，则可以改用traverse_，它会返回State[Network, Unit]。最后，如果您想“汇总”结果T，并且T形成Monoid，则可以使用foldMap中的Foldable，它将返回State[Network, T]，其中T是链中所有T的组合（例如折叠）结果。

代码示例
现在，通过代码示例获取更多详细信息。我将使用Cats State而不是Scalaz来回答这个问题，因为我从未使用过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代表2D平面中的一个点，而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]，我们想将它们顺序应用于初始状态，然后得到结果：我们使用{{3 }}。

traverse

或者，如果您根本不需要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）：

String

最后一种方法是否对您有用，实际上取决于您拥有的val result : State[Position,String] = moves.foldMap(move) result.run(Position()).value // (Position(-1,-1),Down!Down!Left!Up!)以及将其组合起来是否有意义。

这应该是您方案中所需要的。

与状态Monad链接许多转换

1 个答案: