Как составить две разные `State Monad`?

Как я упоминал в своем первом комментарии, будет невозможно использовать для понимания, чтобы делать то, что вы хотите, потому что он не может изменить тип состояния (S).

Помните, что для понимания можно перевести как комбинацию flatMaps, withFilter и одного map. Если мы посмотрим на ваш State.flatMap, то потребуется функция f, чтобы превратить State[S,A] в State[S, B]. Мы можем использовать flatMap и map (и, таким образом, a для понимания) для объединения операций в одном и том же состоянии, но мы не можем изменить тип состояния в этой цепочке.

Мы могли бы обобщить ваше последнее определение myAction, чтобы объединить, составить, ... две функции, использующие состояние другого типа. Мы можем попытаться реализовать этот обобщенный метод компоновки непосредственно в нашем классе State (хотя это, вероятно, настолько специфично, что, вероятно, не принадлежит классу State). Если мы посмотрим на State.flatMap и myAction, то увидим некоторое сходство:

• Сначала мы вызываем runState для нашего существующего экземпляра State.
• Затем мы снова вызываем runState

В myAction мы сначала используем результат n2 для создания State[Int, String] (AppendBang[String] или State[S2, B]) с помощью второй функции (appendBang или f), для которой мы затем вызываем runState. Но наш результат 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)

Редактировать: идея Берджи создать две функции для преобразования 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)
  }
}

Таким образом, вы можете использовать a для понимания, так как тип состояния остается прежним ((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 !!!)