理解 Scala 以便理解本示例代码

Question

我是 Scala 世界的新手，对以下代码有一些疑问。

sealed trait Input
case object Coin extends Input
case object Turn extends Input

case class Machine(locked: Boolean, candies: Int, coins: Int)

object Candy {
  def update = (i: Input) => (s: Machine) =>
    (i, s) match {
      case (_, Machine(_, 0, _)) => s
      case (Coin, Machine(false, _, _)) => s
      case (Turn, Machine(true, _, _)) => s
      case (Coin, Machine(true, candy, coin)) =>
        Machine(false, candy, coin + 1)
      case (Turn, Machine(false, candy, coin)) =>
        Machine(true, candy - 1, coin)
    }

  def simulateMachine(inputs: List[Input]): State[Machine, (Int, Int)] = for {
    _ <- sequence(inputs map (modify[Machine] _ compose update))
    s <- get
  } yield (s.coins, s.candies)
}

case class State[S, +A](run: S => (A, S)) {
  def map[B](f: A => B): State[S, B] =
    flatMap(a => unit(f(a)))
  def map2[B,C](sb: State[S, B])(f: (A, B) => C): State[S, C] =
    flatMap(a => sb.map(b => f(a, b)))
  def flatMap[B](f: A => State[S, B]): State[S, B] = State(s => {
    val (a, s1) = run(s)
    f(a).run(s1)
  })
}
object State {
    def modify[S](f: S => S): State[S, Unit] = for {
        s <- get // Gets the current state and assigns it to `s`.
        _ <- set(f(s)) // Sets the new state to `f` applied to `s`.
    } yield ()

    def get[S]: State[S, S] = State(s => (s, s))

    def set[S](s: S): State[S, Unit] = State(_ => ((), s))

    def sequence[S,A](sas: List[State[S, A]]): State[S, List[A]] =
        sas.foldRight(unit[S, List[A]](List()))((f, acc) => f.map2(acc)(_ :: _))

    def unit[S, A](a: A): State[S, A] =
        State(s => (a, s))
}

1. 在simulateMachine方法中，第一个和第二个_什么？ 感觉第一个是被忽略的输出，这两个代表相同的值吗？
2. get来自State，它是如何获取Machine的状态的？
3. yield输出一个元组，它如何匹配返回类型State[Machine, (Int, Int)]
4. 如何调用这个simulateMachine方法？ 看起来我需要在某处启动机器状态。

我认为这份文件无法让我正确理解幕后发生的事情。 我怎样才能更好地理解它？

Answer 1

这是一个稍微冗长的simulateMachine版本，应该更容易理解。

def simulateMachine(inputs: List[Input]): State[Machine, (Int, Int)] = for {
    _ <- State.sequence(  // this _ means "discard this 'unpacked' value"
      inputs.map(
        (State.modify[Machine] _).compose(update) // this _ is an eta-expansion
      )
    )
    s <- State.get
  } yield (s.coins, s.candies)

“解包” value - for { value <- container } ...基本上是从container “解包” value 。 解包的语义在不同的容器之间是不同的——最直接的是List或Seq语义，其中value每个项目都变成了value ，在这种情况下， for语义变成了迭代。 其他值得注意的“容器”是：

• Option - for语义：值存在与否 + 值的修改（如果存在）
• Try - for语义：成功的计算与否 + 成功的修改
• Future - for语义：定义当值出现时要执行的计算链

实际上，每一个单子（解释什么单子是为haaard :)试试这个为起点）定义的方式来“解压”和“迭代”。 你的State实际上是一个单子（即使它没有明确地声明这一点）（顺便说一句和，有一个规范的State单子，你可以在第三方找到库，如猫或scalaz ）

Eta-expansion在这个 SO answer 中进行了解释，但简而言之，它将函数/方法转换为函数对象。 大致相当于x => State.modify[Machine](x)

或者完全脱糖的版本：

def simulateMachine(inputs: List[Input]): State[Machine, (Int, Int)] = {
    val simulationStep: Input => State[Machine, Unit] = (State.modify[Machine] _).compose(update) // this _ is an eta-expansion

    State.sequence(inputs.map(input => simulationStep(input)))
      .flatMap(_ => State.get)  // `_ => xyz` creates a function that does not care about it's input
      .map(machine => (machine.candies, machine.coins))
  }

请注意，使用的_中_ => State.get还有另一种方法_使用-现在，它创建一个不关心它的参数的函数。

现在，回答被问到的问题：

1. 看上面 ：）
2. 如果您查看脱糖版本，您会看到State.get作为“回调”传递给flatMap 。 有几个环节可以跳过以跟踪它（我将把它作为练习留给你:)），但本质上它所做的是用状态本身（ A ）替换状态（ A ）的“结果”部分（ S ))。 这里的技巧是它根本没有得到Machine ——它只是“链接”一个调用，以从状态的S部分“获取” Machine到状态的A部分。
3. 我认为脱糖版本应该是不言自明的。 关于 for-comprehension 版本 - for使用链中的第一个调用修复“上下文”，因此其他所有内容（包括yield ）都在该“上下文”中执行 - 具体来说，它固定为State[_, _] 。 yield本质上相当于在链尾调用map ，在State[_, _]语义中，map 替换了A部分，但保留了S部分。
4. Candy.simulateMachine(List(Coin, Turn, Coin, Turn)).run(Machine(false, 2, 0))

PS 您当前的代码仍然State.set方法。 我假设它只是def set[S](s: => S): State[S, S] = State(_ => (s, s)) - 至少添加这会使您的代码段在我的环境中编译。