mirror of
https://github.com/apple/swift-async-algorithms
synced 2026-11-22 04:10:40 +00:00
* Rework `AsyncStreaming` protocols to use generic `RangeReplaceableContainer` buffers Replace `InputSpan`/`OutputSpan` with generic `Buffer` associated types constrained to `RangeReplaceableContainer` across all four streaming protocols. This sidesteps the limitation that `OutputSpan` (and other `~Escapable` types) cannot be used in async contexts today, while still allowing conforming types to choose a buffer representation optimized for their use case (e.g. `UniqueArray` for heap-backed storage, or a future stack-allocated container for embedded). Switch callee-owned protocols from `consuming` to `inout` closure semantics, rename `forEachChunk` to `forEachBuffer`, and move `forEach`/`collect` to future directions in the proposal. Adds test coverage for `AsyncWriter`, `CallerAsyncReader`, and `EitherError`. Updates all documentation to reflect the new API surface. * Fix a few new region isolation errors in `nightly-main` Region isolation got smarter and started diagnosing more potential data races. This PR addresses the new errors. Importantly I had to introduce one `@unchecked Sendable` conformance since we can't yet use `UniqueDeque`
55 lines
1.7 KiB
Swift
55 lines
1.7 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift Async Algorithms open source project
|
|
//
|
|
// Copyright (c) 2022 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#if UnstableAsyncStreaming && compiler(>=6.4)
|
|
/// A type-safe wrapper around one of two distinct error types.
|
|
///
|
|
/// Use ``EitherError`` when an operation can fail with errors from two
|
|
/// different sources, such as a read failure and a body closure failure.
|
|
@frozen
|
|
public enum EitherError<First: Error, Second: Error>: Error {
|
|
/// An error of the first type.
|
|
case first(First)
|
|
|
|
/// An error of the second type.
|
|
case second(Second)
|
|
|
|
/// Throws the underlying error, unwrapping this ``EitherError``.
|
|
///
|
|
/// This method extracts and throws the contained error,
|
|
/// whether it's the first or second type. Use this when you need to propagate
|
|
/// the original error without the ``EitherError`` wrapper.
|
|
///
|
|
/// - Throws: The underlying error, either of type `First` or `Second`.
|
|
///
|
|
/// ## Example
|
|
///
|
|
/// ```swift
|
|
/// do {
|
|
/// let result = try await operation()
|
|
/// } catch let eitherError as EitherError<NetworkError, ParseError> {
|
|
/// try eitherError.unwrap()
|
|
/// }
|
|
/// ```
|
|
public func unwrap() throws {
|
|
switch self {
|
|
case .first(let first):
|
|
throw first
|
|
case .second(let second):
|
|
throw second
|
|
}
|
|
}
|
|
}
|
|
|
|
extension EitherError: Equatable where First: Equatable, Second: Equatable {}
|
|
extension EitherError: Hashable where First: Hashable, Second: Hashable {}
|
|
#endif
|