scala - 使用 Control.Parallel 将 Haskell 代码移植到 Scala

Question

下面的 Haskell 代码使用 par和 pseq做一些多核数字运算作为玩具来显示正在使用的几个核心。在 Scala 中表达这一点的最简单和最惯用的方法是什么？ Futures 和 Promises 看起来很有希望(咳咳)，我一直在看 scalaz.concurrent ，例如this example ，但我找不到文档来解释这一切。

import Control.Parallel

main = a `par` b `par` c `pseq` print (a + b + c)
  where
      a = ack 3 10
      b = fac 42
      c = fib 35

fac 0 = 1
fac n = n * fac (n-1)

ack 0 n = n+1
ack m 0 = ack (m-1) 1
ack m n = ack (m-1) (ack m (n-1))

fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

Answer 1

您可以像这样在 Scala 中翻译您的示例:

import concurrent.{Await, Future, future}
import concurrent.ExecutionContext.Implicits.global
import concurrent.duration.Duration

object Main extends App {

  val fac: Int => Int = {
    case 0 => 1
    case n => n * fac(n-1)
  }

  val ack: (Int, Int) => Int = {
    case (0, n) => n + 1
    case (m, 0) => ack (m-1, 1)
    case (m, n) => ack (m-1, ack(m, n-1))
  }

  val fib: Int => Int = {
    case 0 => 0
    case 1 => 1
    case n => fib(n-1) + fib(n-2)
  }

  val fa = future { ack(3, 10) }
  val fb = future { fac(42) }
  val fc = future { fib(35) }

  val x = for (((a, b), c) <- fa zip fb zip fc) yield (a + b + c)

  val result = Await.result(x, Duration.Inf) //awaiting synchronously after the result
  println(s"Value is: $result")

}

future { fib(3, 10) } bit 将创建一个异步计算，该计算将在不同的执行线程上运行并返回 Future目的。然后，您可以使用 Future.sequence 将所有 future 组合成一个大 future ，该 future 将提供所有结果的列表。 .

我们可以将后面这个future的结果映射到结果的总和中，从而得到最终的值。

有了这个最终的 future ，我们可以做几件事。我们可以进一步组合它，或者我们可以在其上附加回调，或者我们可以同步等待指定的持续时间。在我的示例中，我在无限期的结果之后以同步方式等待。