如何组成两个不同的`State Monad`？

Question

当我学习State Monad时，我不知道如何组合两个具有不同State返回类型的函数。

状态单子定义：

case class State[S, A](runState: S => (S, A)) {

  def flatMap[B](f: A => State[S, B]): State[S, B] = {
    State(s => {
      val (s1, a) = runState(s)
      val (s2, b) = f(a).runState(s1)
      (s2, b)
    })
  }

  def map[B](f: A => B): State[S, B] = {
    flatMap(a => {
      State(s => (s, f(a)))
    })
  }

}

两种不同的状态类型：

type AppendBang[A] = State[Int, A]

type AddOne[A] = State[String, A]

两种状态返回类型不同的方法：

def addOne(n: Int): AddOne[Int] = State(s => (s + ".", n + 1))

def appendBang(str: String): AppendBang[String] = State(s => (s + 1, str + " !!!"))

定义一个函数来使用上面的两个函数：

def myAction(n: Int) = for {
  a <- addOne(n)
  b <- appendBang(a.toString)
} yield (a, b)

我希望这样使用它：

println(myAction(1))

问题是myAction 不可编译，报错如下：

Error:(14, 7) type mismatch;
 found   : state_monad.State[Int,(Int, String)]
 required: state_monad.State[String,?]
    b <- appendBang(a.toString)
      ^

我该如何解决？我必须定义一些 Monad 转换器吗？

---

更新：问题可能不清楚，我举个例子

假设我想定义另一个函数，它在内部使用addOne 和appendBang。由于它们都需要现有状态，因此我必须将一些状态传递给它：

def myAction(n: Int)(addOneState: String, appendBangState: Int): ((String, Int), String) = {
  val (addOneState2, n2) = addOne(n).runState(addOneState)
  val (appendBangState2, n3) = appendBang(n2.toString).runState(appendBangState)
  ((addOneState2, appendBangState2), n3)
}

我必须一个一个地运行addOne和appendBang，手动传递和获取状态和结果。

虽然我发现它可以返回另一个State，但代码并没有太大改进：

def myAction(n: Int): State[(String, Int), String] = State {  
case (addOneState: String, appendBangState: Int) =>  
  val (addOneState2, n2) = addOne(n).runState(addOneState)  
  val (appendBangState2, n3) = appendBang(n2.toString).runState(  appendBangState)
    ((addOneState2, appendBangState2), n3)
}

由于我对它们不太熟悉，只是想知道有什么方法可以改进它。最大的希望是我可以使用for 理解，但不确定这是否可能

Answer 1

就像我在第一条评论中提到的那样，使用 for 理解来做你想做的事是不可能的，因为它不能改变状态的类型 (S)。

请记住，for 理解可以转换为 flatMaps、withFilter 和 map 的组合。如果我们查看您的State.flatMap，它需要一个函数f 将State[S,A] 更改为State[S, B]。我们可以使用 flatMap 和 map（因此是一个 for 理解）将同一状态上的操作链接在一起，但我们无法更改此链中状态的类型。

我们可以概括您对myAction 的最后定义，以组合、组合……使用不同类型状态的两个函数。我们可以尝试直接在我们的State 类中实现这个通用的compose 方法（虽然这可能很具体，它可能不属于State）。如果我们查看State.flatMap 和myAction，我们会发现一些相似之处：

• 我们首先在现有的 State 实例上调用 runState。
• 然后我们再次致电runState

在myAction 中，我们首先使用结果n2 创建State[Int, String]（AppendBang[String] 或State[S2, B]），然后使用第二个函数（appendBang 或f）调用@987654346 @。但是我们的结果n2 的类型是String (A) 并且我们的函数appendBang 需要一个Int (B) 所以我们需要一个函数来将A 转换为B。

case class State[S, A](runState: S => (S, A)) {
  // flatMap and map

  def compose[B, S2](f: B => State[S2, B], convert: A => B) : State[(S, S2), B] =
    State( ((s: S, s2: S2) => {
      val (sNext, a) = runState(s)
      val (s2Next, b) = f(convert(a)).runState(s2)
      ((sNext, s2Next), b)
    }).tupled)
}

然后您可以将myAction 定义为：

def myAction(i: Int) = addOne(i).compose(appendBang, _.toString)

val twoStates = myAction(1)
// State[(String, Int),String] = State(<function1>)

twoStates.runState(("", 1))
// ((String, Int), String) = ((.,2),2 !!!)

如果您不希望在 State 类中使用此函数，您可以将其创建为外部函数：

def combineStateFunctions[S1, S2, A, B](
  a: A => State[S1, A], 
  b: B => State[S2, B], 
  convert: A => B
)(input: A): State[(S1, S2), B] = State( 
  ((s1: S1, s2: S2) => {
    val (s1Next, temp) = a(input).runState(s1)
    val (s2Next, result) = b(convert(temp)).runState(s2)
    ((s1Next, s2Next), result)
  }).tupled
)

def myAction(i: Int) = 
  combineStateFunctions(addOne, appendBang, (_: Int).toString)(i)

编辑：Bergi 的想法是创建两个函数以将 State[A, X] 或 State[B, X] 提升为 State[(A, B), X]。

object State {  
  def onFirst[A, B, X](s: State[A, X]): State[(A, B), X] = {
    val runState = (a: A, b: B) => {
      val (nextA, x) = s.runState(a)
      ((nextA, b), x)
    }
    State(runState.tupled)
  }

  def onSecond[A, B, X](s: State[B, X]): State[(A, B), X] = {
    val runState = (a: A, b: B) => {
      val (nextB, x) = s.runState(b)
      ((a, nextB), x)
    }
    State(runState.tupled)
  }
}

这样您就可以使用 for 理解，因为状态的类型保持不变 ((A, B))。

def myAction(i: Int) = for {
  x <- State.onFirst(addOne(i))
  y <- State.onSecond(appendBang(x.toString))
} yield y

myAction(1).runState(("", 1))
// ((String, Int), String) = ((.,2),2 !!!)