Futures（未来）

import Futures

let integers = Stream.sequence(0...)
let primes = integers.filter(isPrime)

var answer = primes.buffer(4)
  .map { $0[0] * $0[1] * $0[3] }
  .first(where: isPronic)

print(answer.wait()) // prints 42

import Futures

// Create *executors* to spawn *tasks* on. Each QueueExecutor
// is backed by a private serial DispatchQueue.
let deepThought = (
  cpu0: QueueExecutor(label: "CPU 0"),
  cpu1: QueueExecutor(label: "CPU 1"),
  cpu2: QueueExecutor(label: "CPU 2")
)

// Create two *channels* via which values can be communicated
// between parts of the program.
let pipe1 = Channel.makeUnbuffered(itemType: Int.self)
let pipe2 = Channel.makeUnbuffered(itemType: Int.self)

// Spawn a task that produces positive integers on one
// executor and sends the values to one of the channels.
let integers = Stream.sequence(0...)
deepThought.cpu1.submit(integers.forward(to: pipe1))

// Spawn another task on the second executor that receives
// these values, filters out non-prime integers and sends
// the remaining down the second channel.
let primes = pipe1.makeStream().filter(isPrime)
deepThought.cpu2.submit(primes.forward(to: pipe2))

// Spawn a third task on the third executor that receives
// the prime numbers via the channel and performs the actual
// computation of the answer. For this task, we ask for a
// handle back, with which we can get the final result or
// cancel it.
var answer = deepThought.cpu0.spawn(
  pipe2.makeStream()
    .buffer(4)
    .map { $0[0] * $0[1] * $0[3] }
    .first(where: isPronic)
)

// At this point, everything happens asynchronously in
// secondary background threads, so the program would just
// exit. We need the answer first however, so we block the
// current thread waiting for the result of the computation
// which we just print to standard output.
print(answer.wait()) // prints "Result.success(42)"

import Foundation

func isPrime(_ n: Int) -> Bool {
  return n == 2 || n > 2 && (2...(n - 1)).allSatisfy {
    !n.isMultiple(of: $0)
  }
}

func isPronic(_ n: Int) -> Bool {
  let f = floor(Double(n).squareRoot())
  let c = ceil(Double(n).squareRoot())
  return n == Int(f) * Int(c)
}

.package(url: "https://github.com/dfunckt/swift-futures.git", .upToNextMinor(from: "0.1.0"))

// swift-tools-version:5.0
import PackageDescription

let package = Package(
  name: "MyApp",
  products: [
    .executable(name: "MyApp", targets: ["MyTarget"]),
  ],
  dependencies: [
    .package(url: "https://github.com/dfunckt/swift-futures.git", .upToNextMinor(from: "0.1.0")),
  ],
  targets: [
    .target(name: "MyTarget", dependencies: ["Futures"]),
  ]
)