scala - 令人困惑的 Scala 语法

Question

试图理解一些 scala 语法，以及在哪里可以找到它们的规范。下面我对 statefulMapConcat 感到困惑。

签名是这个:

def statefulMapConcat[T](f: () => Out => immutable.Iterable[T]): Repr[T]

我们有

"be able to restart" in {
      Source(List(2, 1, 3, 4, 1))
        .statefulMapConcat(() => {
          var prev: Option[Int] = None
          x => {
            if (x % 3 == 0) throw ex
            prev match {
              case Some(e) =>
                prev = Some(x)
                (1 to e).map(_ => x)
              case None =>
                prev = Some(x)
                List.empty[Int]
            }
          }
        })
        .withAttributes(ActorAttributes.supervisionStrategy(Supervision.restartingDecider))
        .runWith(TestSink.probe[Int])
        .request(2)
        .expectNext(1, 1)
        .request(4)
        .expectNext(1, 1, 1, 1)
        .expectComplete()
    }

我怎么不好好下

{
          var prev: Option[Int] = None
          x => {
            if (x % 3 == 0) throw ex
            prev match {
              case Some(e) =>
                prev = Some(x)
                (1 to e).map(_ => x)
              case None =>
                prev = Some(x)
                List.empty[Int]
            }
          }

对应于

Out => immutable.Iterable[T]

有人可以帮我分解一下吗？

在我心中x将对应于 Out , 但是我们在 var prev: Option[Int] = None 之前声明了一个变量

我想了解有关一般 scala 魔术的一般解释以及在哪里可以找到解释

Answer 1

这里要理解的两个关键概念是

• 整个 block 表达式的值是 block 中最后表达式的值，并且
• 函数是一流的值

考虑以下 block 表达式

{
  var prev: Option[Int] = None
  42 // I am the last value of the block
}

因为 block 中最后一个表达式的计算结果为 42，所以整个 block 的值为 42，类型为 Int。

类似地，考虑下面的 block 表达式

{
  var prev: Option[Int] = None
  (x: Int) => { x + 1 } // I am also the last *value* of the block
}

因为 block 中的最后一个表达式的计算结果为值 (x: Int) => { x + 1 }，所以整个 block 的值是 value (x: Int) = > { x + 1 } 类型 Int => Int。

在这两种情况下，因为表达式 var prev: Option[Int] = None 不是 block 中的最后一个表达式，所以它不会影响整个 block 的值的类型。