Swift Async Algorithms

Swift Async Algorithms is an open-source package providing asynchronous sequence and advanced algorithms that involve concurrency. It focuses on:

• First-class integration with async/await.
• Time-based algorithms (e.g., debounce, throttle).
• Order-based algorithms (e.g., combineLatest, merge).
• Cross-platform support.

The package provides a variety of asynchronous sequence algorithms and related types. Key topics include:

• Sequence Manipulation: AdjacentPairs, Chain, Chunked, Compacted, Intersperse, Joined, RemoveDuplicates, Zip.
• Concurrency & Timing: Debounce, Throttle, Timer, Merge, CombineLatest.
• Buffering & Flow Control: BufferedBytes, Channel, Share.
• State & Accumulation: Reductions, Collections.
• Advanced Patterns: Effects, Lazy.

Producers can be notified when the channel terminates (e.g., due to task cancellation or the channel being deinitialized) by using source.setOnTerminationCallback.

Termination of the producer occurs when:

• The task consuming the channel is cancelled.
• The channel itself is deinitialized.
• The source is finished and all elements are consumed.
• All sources (including additional sources) are deinitialized and all elements are consumed.

let channelAndSource = MultiProducerSingleConsumerAsyncChannel.makeChannel(
    of: Int.self,
    backpressureStrategy: .watermark(low: 2, high: 4)
)
var channel = consume channelAndSource.channel
var source = consume channelAndSource.source
source.setOnTerminationCallback { print("Terminated") }

let task = Task {
    await channel.next()
}
task.cancel() // Prints "Terminated"

The validate function allows you to test AsyncSequence implementations using a visual, time-based domain-specific language (DSL). You can define inputs as strings where characters represent values or control events, specify the transformation logic, and define the expected output string. This approach provides deterministic testing for asynchronous sequences by explicitly defining the ordering of time.

Key features:

• Time progression: Use - to advance time.
• Termination: Use | to represent the sequence returning nil.
• Multiple Inputs: Result builders allow testing operators like merge by providing multiple input specifications.
• Visual Alignment: Spaces are ignored in terms of time advancement; they are used for visual alignment and do not represent events.

validate {
  "a--b--c---|"
  $0.inputs[0].map { $0.capitalized }
  "A--B--C---|"
}

If you have an AsyncSequence containing optional values, you can use the compacted() method to filter out nil values and return a sequence of unwrapped elements. This is a more efficient alternative to .compactMap { $0 } because it avoids the overhead of executing and storing a closure.

Behaviorally, compacted() is equivalent to .compactMap { $0 }. The resulting sequence will throw if the base sequence throws, and will not throw if the base sequence does not throw.

Use the interspersed(with:) method to insert a separator value between every element of an asynchronous sequence. The separator is only placed between elements; it is not added before the first element or after the last element.

• If the base sequence is empty, the resulting sequence is also empty.
• If the base sequence throws during iteration, AsyncInterspersedSequence will also throw.
• AsyncInterspersedSequence is conditionally Sendable if both the base sequence and the element type are Sendable.

let numbers = [1, 2, 3].async.interspersed(with: 0)
for await number in numbers {
  print(number)
}
// prints 1 0 2 0 3

let empty = [].async.interspersed(with: 0)
// await Array(empty) == []