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>
78 lines
3.0 KiB
Swift
78 lines
3.0 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, *)
|
|
extension AsyncSequence where Self: Sendable {
|
|
/// Transforms elements into new asynchronous sequences, emitting elements
|
|
/// from the most recent inner sequence.
|
|
///
|
|
/// When a new element is emitted by this sequence, the `transform`
|
|
/// is called to produce a new inner sequence. Iteration on the
|
|
/// previous inner sequence is cancelled, and iteration begins
|
|
/// on the new one.
|
|
|
|
public func flatMapLatest<T: AsyncSequence & Sendable>(
|
|
_ transform: @escaping @Sendable (Element) -> T
|
|
) -> some AsyncSequence<T.Element, T.Failure> & Sendable where T.Failure == Failure, T.Element: Sendable, Element: Sendable {
|
|
return AsyncFlatMapLatestSequence(self, transform: transform)
|
|
}
|
|
|
|
@_disfavoredOverload
|
|
public func flatMapLatest<T: AsyncSequence & Sendable>(
|
|
_ transform: @escaping @Sendable (Element) -> T
|
|
) -> some AsyncSequence<T.Element, Failure> & Sendable where T.Failure == Never, T.Element: Sendable, Element: Sendable {
|
|
return AsyncFlatMapLatestSequence(self) {
|
|
transform($0).mapError { _ -> Failure in
|
|
fatalError()
|
|
}
|
|
}
|
|
}
|
|
|
|
@_disfavoredOverload
|
|
public func flatMapLatest<T: AsyncSequence & Sendable>(
|
|
_ transform: @escaping @Sendable (Element) -> T
|
|
) -> some AsyncSequence<T.Element, T.Failure> & Sendable where Failure == Never, T.Element: Sendable, Element: Sendable {
|
|
return AsyncFlatMapLatestSequence(self.mapError { _ -> T.Failure in
|
|
fatalError()
|
|
}, transform: transform)
|
|
}
|
|
}
|
|
|
|
@available(AsyncAlgorithms 1.1, *)
|
|
struct AsyncFlatMapLatestSequence<Base: AsyncSequence & Sendable, Inner: AsyncSequence & Sendable>: AsyncSequence, Sendable where Base.Element: Sendable, Inner.Element: Sendable, Base.Failure == Inner.Failure{
|
|
typealias Element = Inner.Element
|
|
typealias Failure = Inner.Failure
|
|
|
|
let base: Base
|
|
let transform: @Sendable (Base.Element) -> Inner
|
|
|
|
init(_ base: Base, transform: @escaping @Sendable (Base.Element) -> Inner) {
|
|
self.base = base
|
|
self.transform = transform
|
|
}
|
|
|
|
func makeAsyncIterator() -> Iterator {
|
|
return Iterator(base: base, transform: transform)
|
|
}
|
|
|
|
struct Iterator: AsyncIteratorProtocol, Sendable {
|
|
let storage: FlatMapLatestStorage<Base, Inner>
|
|
|
|
init(base: Base, transform: @escaping @Sendable (Base.Element) -> Inner) {
|
|
self.storage = FlatMapLatestStorage(base: base, transform: transform)
|
|
}
|
|
|
|
func next(isolation: isolated (any Actor)? = #isolation) async throws(Failure) -> Element? {
|
|
return try await storage.next(isolation: isolation)
|
|
}
|
|
}
|
|
}
|