mirror of
https://github.com/apple/swift-async-algorithms
synced 2026-11-22 04:10:40 +00:00
* feat: Add initial naive implementation of flatMapLatest This introduces a simplified version of the flatMapLatest operator for AsyncSequence, along with a basic unit test. Note that this implementation uses unstructured concurrency and may have race conditions regarding task cancellation. * refactor: Implement robust flatMapLatest with generation tracking - Replaces naive implementation with a thread-safe approach using ManagedCriticalState. - Introduces generation tracking to prevent race conditions where cancelled inner sequences could yield stale values. - Adds test_interleaving_race_condition to verify correctness under concurrent load. - Ensures Swift 6 Sendable compliance. * refactor: Implement high-performance State Machine for flatMapLatest - Replaces AsyncThrowingStream implementation with a custom AsyncSequence, Storage, and StateMachine. - Implements explicit state management using Lock for thread safety. - Handles concurrency between outer and inner sequences robustly. - Ensures correct cancellation propagation and error handling. - Verified with test_interleaving_race_condition. * refactor: Split flatMapLatest into separate files - Moves AsyncFlatMapLatestSequence.swift to Sources/AsyncAlgorithms/FlatMapLatest/ - Extracts FlatMapLatestStateMachine and FlatMapLatestStorage into their own files. - Aligns project structure with other complex operators like CombineLatest and Debounce. * test: Add comprehensive tests for flatMapLatest - Added test_outer_throwing to verify outer sequence error propagation - Added test_inner_throwing to verify inner sequence error propagation - Added test_cancellation to verify proper cancellation handling - Added test_empty_outer to verify empty outer sequence handling - Added test_empty_inner to verify empty inner sequence handling - Fixed test_simple_sequence to be more robust against timing issues * fix: Make test_outer_throwing stable - Changed from synchronous map with throwIf to AsyncThrowingStream - Added delay to ensure proper error propagation timing - Fixes intermittent test failures * refactor: Clean up verbose comments in FlatMapLatestStateMachine - Removed LLM-style thinking comments - Kept only essential, professional explanations - No functional changes, all tests pass * docs: Add comprehensive guide for flatMapLatest - Added FlatMapLatest.md documentation guide - Authored by Peter Friese - Includes introduction, code samples, and use cases - Covers search-as-you-type, location-based data, and dynamic config examples - Compares with similar operators in ReactiveX and Combine * docs: Add evolution proposal for flatMapLatest - Created SAA-00nn proposal for flatMapLatest operator - Includes motivation, detailed design, and examples - Covers implementation strategy with state machine - Compares with ReactiveX switchMap and Combine switchToLatest * mapError - transforming failures (#366) * Implement AsyncMapErrorSequence * Update the proposal, implementation and tests with formatting, additional details and modifications for being able to push it to a review * Foratting and preambles * Update Copyright date for error sequence Co-authored-by: Clive <clive819@users.noreply.github.com> * Update copyright year for mapError tests Co-authored-by: Clive <clive819@users.noreply.github.com> * Update availablity and modify the mapError algorithm to be opaque * Correct pre 6.0 build avail parameters * Make the formatting of the algorithm accesor a bit more consistent * Update the 5.8 package builder to define 1.2 * re-run formatter --------- Co-authored-by: Clive <clive819@gmail.com> Co-authored-by: Clive <clive819@users.noreply.github.com> * Update the flatMapLatest proposal and implementation to a pitchable state * Fix race condition in flatMapLatest and add regression test * chore: Remove test_output.log and add it to .gitignore --------- Co-authored-by: Philippe Hausler <phausler@apple.com> Co-authored-by: Clive <clive819@gmail.com> Co-authored-by: Clive <clive819@users.noreply.github.com>
201 lines
6.4 KiB
Swift
201 lines
6.4 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift Async Algorithms open source project
|
|
//
|
|
// Copyright (c) 2025 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
@available(AsyncAlgorithms 1.1, *)
|
|
final class FlatMapLatestStorage<Base: AsyncSequence & Sendable, Inner: AsyncSequence & Sendable>: @unchecked Sendable where Base.Element: Sendable, Inner.Element: Sendable {
|
|
typealias Element = Inner.Element
|
|
|
|
private let lock = Lock.allocate()
|
|
private var stateMachine: FlatMapLatestStateMachine<Base, Inner>
|
|
|
|
init(base: Base, transform: @escaping @Sendable (Base.Element) -> Inner) {
|
|
self.stateMachine = FlatMapLatestStateMachine(base: base, transform: transform)
|
|
}
|
|
|
|
deinit {
|
|
lock.deinitialize()
|
|
}
|
|
|
|
func next(isolation: isolated (any Actor)? = #isolation) async throws(Inner.Failure) -> Inner.Element? {
|
|
do {
|
|
return try await withTaskCancellationHandler {
|
|
lock.lock()
|
|
let action = stateMachine.next()
|
|
|
|
switch action {
|
|
case .returnElement(let element):
|
|
lock.unlock()
|
|
return element
|
|
|
|
case .returnNil:
|
|
lock.unlock()
|
|
return nil
|
|
|
|
case .throwError(let error):
|
|
lock.unlock()
|
|
throw error
|
|
|
|
case .startOuterTask(let base):
|
|
// We need to start the outer task and then suspend
|
|
startOuterTask(base)
|
|
|
|
return try await suspend()
|
|
|
|
case .suspend:
|
|
lock.unlock()
|
|
return try await suspend()
|
|
}
|
|
} onCancel: {
|
|
let action = lock.withLock { stateMachine.cancelled() }
|
|
handleAction(action)
|
|
}
|
|
} catch {
|
|
throw error as! Inner.Failure
|
|
}
|
|
}
|
|
|
|
private func suspend() async throws -> Element? {
|
|
return try await withUnsafeThrowingContinuation { continuation in
|
|
let action = lock.withLock { stateMachine.next(for: continuation) }
|
|
|
|
switch action {
|
|
case .resumeOuterContinuation(let continuation):
|
|
continuation.resume()
|
|
case .resumeInnerContinuation(let continuation):
|
|
continuation.resume()
|
|
case .none:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
private func startOuterTask(_ base: Base) {
|
|
let task = Task {
|
|
var iterator = base.makeAsyncIterator()
|
|
|
|
loop: while true {
|
|
// Create a continuation to wait for demand
|
|
do {
|
|
try await withUnsafeThrowingContinuation { continuation in
|
|
let action = lock.withLock { stateMachine.outerTaskSuspended(continuation) }
|
|
|
|
switch action {
|
|
case .resumeOuterContinuation(let continuation):
|
|
continuation.resume()
|
|
case .resumeInnerContinuation(let continuation):
|
|
continuation.resume()
|
|
case .none:
|
|
break
|
|
}
|
|
}
|
|
} catch {
|
|
// Cancellation or other error during suspension
|
|
let action = lock.withLock { stateMachine.outerThrew(error) }
|
|
handleAction(action)
|
|
break loop
|
|
}
|
|
|
|
do {
|
|
if let element = try await iterator.next() {
|
|
let action = lock.withLock { stateMachine.outerElementProduced(element) }
|
|
handleAction(action)
|
|
} else {
|
|
let action = lock.withLock { stateMachine.outerFinished() }
|
|
handleAction(action)
|
|
break loop
|
|
}
|
|
} catch {
|
|
let action = lock.withLock { stateMachine.outerThrew(error) }
|
|
handleAction(action)
|
|
break loop
|
|
}
|
|
}
|
|
}
|
|
stateMachine.outerTaskStarted(task)
|
|
lock.unlock()
|
|
}
|
|
|
|
private func startInnerTask(_ inner: Inner, generation: Int) {
|
|
let task = Task {
|
|
var iterator = inner.makeAsyncIterator()
|
|
|
|
loop: while true {
|
|
// Wait for demand
|
|
do {
|
|
try await withUnsafeThrowingContinuation { continuation in
|
|
let action = lock.withLock { stateMachine.innerTaskSuspended(continuation, generation: generation) }
|
|
|
|
switch action {
|
|
case .resumeInnerContinuation(let continuation):
|
|
continuation.resume()
|
|
case .resumeOuterContinuation(let continuation):
|
|
continuation.resume()
|
|
case .none:
|
|
break
|
|
}
|
|
}
|
|
} catch {
|
|
// Cancellation
|
|
let action = lock.withLock { stateMachine.innerThrew(error, generation: generation) }
|
|
handleAction(action)
|
|
break loop
|
|
}
|
|
|
|
do {
|
|
if let element = try await iterator.next() {
|
|
let action = lock.withLock { stateMachine.innerElementProduced(element, generation: generation) }
|
|
handleAction(action)
|
|
} else {
|
|
let action = lock.withLock { stateMachine.innerFinished(generation: generation) }
|
|
handleAction(action)
|
|
break loop
|
|
}
|
|
} catch {
|
|
let action = lock.withLock { stateMachine.innerThrew(error, generation: generation) }
|
|
handleAction(action)
|
|
break loop
|
|
}
|
|
}
|
|
}
|
|
stateMachine.innerTaskStarted(task, generation: generation)
|
|
}
|
|
|
|
private func handleAction(_ action: FlatMapLatestStateMachine<Base, Inner>.Action) {
|
|
switch action {
|
|
case .startInnerTask(let inner, let generation, let previousTask, let previousCont):
|
|
if let previousTask = previousTask {
|
|
previousTask.cancel()
|
|
previousCont?.resume(throwing: CancellationError())
|
|
}
|
|
startInnerTask(inner, generation: generation)
|
|
|
|
case .cancelInnerTask(let task, let continuation):
|
|
task.cancel()
|
|
continuation?.resume(throwing: CancellationError())
|
|
|
|
case .resumeDownstream(let continuation, let result):
|
|
continuation.resume(with: result)
|
|
|
|
case .resumeOuterContinuation(let continuation):
|
|
continuation.resume()
|
|
|
|
case .cancelTasks(let outer, let inner, let outerCont, let innerCont):
|
|
outer?.cancel()
|
|
inner?.cancel()
|
|
outerCont?.resume(throwing: CancellationError())
|
|
innerCont?.resume(throwing: CancellationError())
|
|
|
|
case .none:
|
|
break
|
|
}
|
|
}
|
|
}
|