在 scalaz 中组合状态的标准方法

Question

考虑一下，您有状态的 Nel（Nel 代表 NonEmptyList，为了使事情更短），并且您想将状态合并为一个状态，使用一些函数 f，用于状态的左侧部分和 g为右半部分状态。

所以你想要这样的东西：

def foldStatesG[S, A](in: NonEmptyList[State[S, A]])(f: (A, A) => A)(g: (S, S) => S): State[S, A] = {
    in.foldLeft1((s1, s2) => State(e => {
      val ss1 = s1(e)
      val ss2 = s2(e)
      g(ss1._1, ss2._1) -> f(ss1._2, ss2._2)
    }))
  }

我敢肯定，我正在发明自行车，而且这种东西已经存在，可能以更普遍的方式存在。但是，通过 scalaz 我没能找到或认出它。如果您对此主题有任何帮助，我们将不胜感激。

第二个问题，描述了我是如何遇到这样的问题的。我想做一个小模拟，当你有一个敌人（考虑它只是一个替身）和所有可能击中他的法术时 Nel[Spell]。所以基本上我想生成所有可能的序列。例如，如果 Nel[Spell] = ($, #)，那么给定一个敌人 E，进度看起来像

E -> (), then Nel(E -> $, E -> #), then Nel(E -> $$, E -> ##, E -> $#, E-> #$) etc.. (pseudo code)

无需赘述，我需要这样的东西：

def combineS(variations: NonEmptyList[Spell]): State[NonEmptyList[(Enemy, List[Spell])], Boolean]

也就是说，你给它提供所有可能的走法，它模拟所有可能的状态。您可以将其视为一种决策树，每一步都会分支。因此，我定义了如何进行一个咒语。

def combineS1(spell: Spell): State[(NonEmptyList[(Enemy, List[Spell])]), Boolean]
    // some logic

问题是，我无法通过简单的遍历实现它：

def combineS(variations: NonEmptyList[Spell]): State[NonEmptyList[(Enemy, List[Spell])], Boolean] = {
    val x = variations traverse combine1 // State[Nel[..], Nel[Boolean]
    x map { _.suml1(conjunction)}
}

因为在traverse中，Nels并没有相互追加，而是被丢弃了。这就是我想出这个解决方案的原因：

  def combineS(variations: NonEmptyList[Spell]): State[NonEmptyList[(Enemy, List[Spell])], AllDead] = {
    val x: NonEmptyList[State[NonEmptyList[(Enemy, List[Spell])], Boolean]] = variations map combineS
    foldStates(x)(_ && _)(append)
  }

该代码确实有效，但我觉得有一种方法可以遍历它，而无需额外的 foldState。

进行此类模拟的其他功能方法是什么（至少在概念方面）。我可以将它简单地写成函数式的，而不用使用高级概念，但这个练习的目的正是为了学习高级的东西。（也许这正是 Writer Monad 的工作？或 Comonad？）

此外，如果 Whosebug 不是解决此类问题的最佳场所，请指出此类问题应该在哪里提出？

Answer 1

好吧，为了回答第一部分，如果我们在另一个宇宙中 Scalaz 已经有一个 Biapplicative 类型 class，我们可以按如下方式使用它：

def foldStatesG[S, A](states: NonEmptyList[State[S, A]], s: (S, S) ⇒ S, a: (A, A) ⇒ A): State[S, A] =
  states.foldLeft1(IndexedStateT.indexedStateTBiapplicative[Id, S].bilift2(s, a))

但我们不这样做，所以我们需要类似下面的内容（n.b。我无法确保这在法律上是明智的）：

trait Biapplicative[F[_, _]] extends Bifunctor[F] {
  def bipure[A, B](a: ⇒ A, b: ⇒ B): F[A, B]
  def biapply[A, B, C, D](fab: ⇒ F[A, B])(f: ⇒ F[A ⇒ C, B ⇒ D]): F[C, D]
  def bilift2[A, B, C, D, E, G](fab: (A, B) ⇒ C, fde: (D, E) ⇒ G): (F[A, D], F[B, E]) ⇒ F[C, G] =
    (fad: F[A, D], fbe: F[B, E]) ⇒
      biapply(fbe)(bimap[A, D, B ⇒ C, E ⇒ G](fad)(fab.curried, fde.curried))
}

object Biapplicative {
  implicit def indexedStateTBiapplicative[F[_], S1](implicit F: Applicative[F]) =
    new Biapplicative[IndexedStateT[F, S1, ?, ?]] {
      def bipure[A, B](a: ⇒ A, b: ⇒ B) =
        StateT.constantIndexedStateT(b)(a)
      def biapply[A, B, C, D]
          (fab: ⇒ IndexedStateT[F, S1, A, B])
          (f: ⇒ IndexedStateT[F, S1, A ⇒ C, B ⇒ D]) =
        new IndexedStateT[F, S1, C, D] {
          def apply(initial: S1): F[(C, D)] =
            F.ap(fab(initial))(F.map(f(initial)) {
              case (a2c, b2d) ⇒ Bifunctor[Tuple2].bimap(_)(a2c, b2d)
            })
        }
    }
}

在 scalaz 中组合状态的标准方法

Standard way to combine States in scalaz

state

functional-programming

scala

scalaz