mirror of
https://github.com/apple/swift-async-algorithms
synced 2026-11-22 04:10:40 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
042e1c4d9d | ||
|
|
57b0814edf | ||
|
|
9fcf11df15 | ||
|
|
08bb1bb014 | ||
|
|
5878737018 | ||
|
|
552856a85c | ||
|
|
ba30f2051b | ||
|
|
d5b49aab17 | ||
|
|
ba33a225e9 |
No files matched your search
@@ -0,0 +1,15 @@
|
||||
name: Pull request
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, reopened, synchronize]
|
||||
|
||||
jobs:
|
||||
tests:
|
||||
name: Test
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
|
||||
soundness:
|
||||
name: Soundness
|
||||
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
|
||||
with:
|
||||
license_header_check_project_name: "Swift Async Algorithms"
|
||||
@@ -0,0 +1,10 @@
|
||||
@@===----------------------------------------------------------------------===@@
|
||||
@@
|
||||
@@ This source file is part of the Swift Async Algorithms open source project
|
||||
@@
|
||||
@@ Copyright (c) YEARS 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
|
||||
@@
|
||||
@@===----------------------------------------------------------------------===@@
|
||||
@@ -0,0 +1,40 @@
|
||||
.gitignore
|
||||
**/.gitignore
|
||||
.licenseignore
|
||||
.gitattributes
|
||||
.mailfilter
|
||||
.mailmap
|
||||
.spi.yml
|
||||
.swift-format
|
||||
.editorconfig
|
||||
.github/*
|
||||
*.md
|
||||
*.txt
|
||||
*.yml
|
||||
*.yaml
|
||||
*.json
|
||||
Package.swift
|
||||
**/Package.swift
|
||||
Package@-*.swift
|
||||
Package@swift-*.swift
|
||||
**/Package@-*.swift
|
||||
Package.resolved
|
||||
**/Package.resolved
|
||||
Makefile
|
||||
*.modulemap
|
||||
**/*.modulemap
|
||||
**/*.docc/*
|
||||
*.xcprivacy
|
||||
**/*.xcprivacy
|
||||
*.symlink
|
||||
**/*.symlink
|
||||
Dockerfile
|
||||
**/Dockerfile
|
||||
Snippets/*
|
||||
dev/git.commit.template
|
||||
*.crt
|
||||
**/*.crt
|
||||
*.pem
|
||||
**/*.pem
|
||||
*.der
|
||||
**/*.der
|
||||
@@ -0,0 +1,58 @@
|
||||
{
|
||||
"fileScopedDeclarationPrivacy" : {
|
||||
"accessLevel" : "private"
|
||||
},
|
||||
"indentation" : {
|
||||
"spaces" : 2
|
||||
},
|
||||
"indentConditionalCompilationBlocks" : false,
|
||||
"indentSwitchCaseLabels" : false,
|
||||
"lineBreakAroundMultilineExpressionChainComponents" : false,
|
||||
"lineBreakBeforeControlFlowKeywords" : false,
|
||||
"lineBreakBeforeEachArgument" : true,
|
||||
"lineBreakBeforeEachGenericRequirement" : true,
|
||||
"lineLength" : 120,
|
||||
"maximumBlankLines" : 1,
|
||||
"prioritizeKeepingFunctionOutputTogether" : true,
|
||||
"respectsExistingLineBreaks" : true,
|
||||
"rules" : {
|
||||
"AllPublicDeclarationsHaveDocumentation" : false,
|
||||
"AlwaysUseLowerCamelCase" : false,
|
||||
"AmbiguousTrailingClosureOverload" : true,
|
||||
"BeginDocumentationCommentWithOneLineSummary" : false,
|
||||
"DoNotUseSemicolons" : true,
|
||||
"DontRepeatTypeInStaticProperties" : true,
|
||||
"FileScopedDeclarationPrivacy" : true,
|
||||
"FullyIndirectEnum" : true,
|
||||
"GroupNumericLiterals" : true,
|
||||
"IdentifiersMustBeASCII" : true,
|
||||
"NeverForceUnwrap" : false,
|
||||
"NeverUseForceTry" : false,
|
||||
"NeverUseImplicitlyUnwrappedOptionals" : false,
|
||||
"NoAccessLevelOnExtensionDeclaration" : true,
|
||||
"NoAssignmentInExpressions" : true,
|
||||
"NoBlockComments" : true,
|
||||
"NoCasesWithOnlyFallthrough" : true,
|
||||
"NoEmptyTrailingClosureParentheses" : true,
|
||||
"NoLabelsInCasePatterns" : false,
|
||||
"NoLeadingUnderscores" : false,
|
||||
"NoParensAroundConditions" : true,
|
||||
"NoVoidReturnOnFunctionSignature" : true,
|
||||
"OneCasePerLine" : true,
|
||||
"OneVariableDeclarationPerLine" : true,
|
||||
"OnlyOneTrailingClosureArgument" : true,
|
||||
"OrderedImports" : false,
|
||||
"ReturnVoidInsteadOfEmptyTuple" : true,
|
||||
"UseEarlyExits" : true,
|
||||
"UseLetInEveryBoundCaseVariable" : false,
|
||||
"UseShorthandTypeNames" : true,
|
||||
"UseSingleLinePropertyGetter" : false,
|
||||
"UseSynthesizedInitializer" : false,
|
||||
"UseTripleSlashForDocumentationComments" : true,
|
||||
"UseWhereClausesInForLoops" : false,
|
||||
"ValidateDocumentationComments" : false
|
||||
},
|
||||
"spacesAroundRangeFormationOperators" : false,
|
||||
"tabWidth" : 4,
|
||||
"version" : 1
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
# file options
|
||||
|
||||
--swiftversion 5.7
|
||||
--exclude .build
|
||||
|
||||
# format options
|
||||
|
||||
--self insert
|
||||
--patternlet inline
|
||||
--ranges nospace
|
||||
--stripunusedargs unnamed-only
|
||||
--ifdef no-indent
|
||||
--extensionacl on-declarations
|
||||
--disable typeSugar # https://github.com/nicklockwood/SwiftFormat/issues/636
|
||||
--disable andOperator
|
||||
--disable wrapMultilineStatementBraces
|
||||
--disable enumNamespaces
|
||||
--disable redundantExtensionACL
|
||||
--disable redundantReturn
|
||||
--disable preferKeyPath
|
||||
--disable sortedSwitchCases
|
||||
--disable hoistAwait
|
||||
--disable hoistTry
|
||||
|
||||
# rules
|
||||
@@ -0,0 +1,7 @@
|
||||
extends: default
|
||||
|
||||
rules:
|
||||
line-length: false
|
||||
document-start: false
|
||||
truthy:
|
||||
check-keys: false # Otherwise we get a false positive on GitHub action's `on` key
|
||||
@@ -51,7 +51,7 @@ would become part of a public API? If so, what kinds of changes can be
|
||||
made without breaking ABI? Can this feature be added/removed without
|
||||
breaking ABI? For more information about the resilience model, see the
|
||||
[library evolution
|
||||
document](https://github.com/apple/swift/blob/master/docs/LibraryEvolution.rst)
|
||||
document](https://github.com/apple/swift/blob/main/docs/LibraryEvolution.rst)
|
||||
in the Swift repository.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
+43
-18
@@ -1,49 +1,74 @@
|
||||
// swift-tools-version: 5.8
|
||||
|
||||
import PackageDescription
|
||||
import CompilerPluginSupport
|
||||
|
||||
// Availability Macros
|
||||
let availabilityTags = [Availability("AsyncAlgorithms")]
|
||||
let versionNumbers = ["1.0"]
|
||||
|
||||
// Availability Macro Utilities
|
||||
enum OSAvailability: String {
|
||||
// This should match the package's deployment target
|
||||
case initialIntroduction = "macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0"
|
||||
case pending = "macOS 9999, iOS 9999, tvOS 9999, watchOS 9999"
|
||||
// Use 10000 for future availability to avoid compiler magic around
|
||||
// the 9999 version number but ensure it is greater than 9999
|
||||
case future = "macOS 10000, iOS 10000, tvOS 10000, watchOS 10000"
|
||||
}
|
||||
|
||||
struct Availability {
|
||||
let name: String
|
||||
let osAvailability: OSAvailability
|
||||
|
||||
init(_ name: String, availability: OSAvailability = .initialIntroduction) {
|
||||
self.name = name
|
||||
self.osAvailability = availability
|
||||
}
|
||||
}
|
||||
|
||||
let availabilityMacros: [SwiftSetting] = versionNumbers.flatMap { version in
|
||||
availabilityTags.map {
|
||||
.enableExperimentalFeature("AvailabilityMacro=\($0.name) \(version):\($0.osAvailability.rawValue)")
|
||||
}
|
||||
}
|
||||
|
||||
let package = Package(
|
||||
name: "swift-async-algorithms",
|
||||
platforms: [
|
||||
.macOS("10.15"),
|
||||
.iOS("13.0"),
|
||||
.tvOS("13.0"),
|
||||
.watchOS("6.0")
|
||||
],
|
||||
products: [
|
||||
.library(name: "AsyncAlgorithms", targets: ["AsyncAlgorithms"]),
|
||||
.library(name: "AsyncAlgorithms", targets: ["AsyncAlgorithms"])
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "AsyncAlgorithms",
|
||||
dependencies: [
|
||||
.product(name: "OrderedCollections", package: "swift-collections"),
|
||||
.product(name: "DequeModule", package: "swift-collections"),
|
||||
.product(name: "OrderedCollections", package: "swift-collections"),
|
||||
.product(name: "DequeModule", package: "swift-collections"),
|
||||
],
|
||||
swiftSettings: [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete"),
|
||||
swiftSettings: availabilityMacros + [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete")
|
||||
]
|
||||
),
|
||||
.target(
|
||||
name: "AsyncSequenceValidation",
|
||||
dependencies: ["_CAsyncSequenceValidationSupport", "AsyncAlgorithms"],
|
||||
swiftSettings: [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete"),
|
||||
swiftSettings: availabilityMacros + [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete")
|
||||
]
|
||||
),
|
||||
.systemLibrary(name: "_CAsyncSequenceValidationSupport"),
|
||||
.target(
|
||||
name: "AsyncAlgorithms_XCTest",
|
||||
dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation"],
|
||||
swiftSettings: [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete"),
|
||||
swiftSettings: availabilityMacros + [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete")
|
||||
]
|
||||
),
|
||||
.testTarget(
|
||||
name: "AsyncAlgorithmsTests",
|
||||
dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation", "AsyncAlgorithms_XCTest"],
|
||||
swiftSettings: [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete"),
|
||||
swiftSettings: availabilityMacros + [
|
||||
.enableExperimentalFeature("StrictConcurrency=complete")
|
||||
]
|
||||
),
|
||||
]
|
||||
@@ -56,6 +81,6 @@ if Context.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
|
||||
]
|
||||
} else {
|
||||
package.dependencies += [
|
||||
.package(path: "../swift-collections"),
|
||||
.package(path: "../swift-collections")
|
||||
]
|
||||
}
|
||||
@@ -8,7 +8,7 @@ let package = Package(
|
||||
.macOS("10.15"),
|
||||
.iOS("13.0"),
|
||||
.tvOS("13.0"),
|
||||
.watchOS("6.0")
|
||||
.watchOS("6.0"),
|
||||
],
|
||||
products: [
|
||||
.library(name: "AsyncAlgorithms", targets: ["AsyncAlgorithms"]),
|
||||
@@ -27,13 +27,16 @@ let package = Package(
|
||||
),
|
||||
.target(
|
||||
name: "AsyncSequenceValidation",
|
||||
dependencies: ["_CAsyncSequenceValidationSupport", "AsyncAlgorithms"]),
|
||||
dependencies: ["_CAsyncSequenceValidationSupport", "AsyncAlgorithms"]
|
||||
),
|
||||
.systemLibrary(name: "_CAsyncSequenceValidationSupport"),
|
||||
.target(
|
||||
name: "AsyncAlgorithms_XCTest",
|
||||
dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation"]),
|
||||
dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation"]
|
||||
),
|
||||
.testTarget(
|
||||
name: "AsyncAlgorithmsTests",
|
||||
dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation", "AsyncAlgorithms_XCTest"]),
|
||||
dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation", "AsyncAlgorithms_XCTest"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// An `AsyncSequence` that iterates over the adjacent pairs of the original
|
||||
/// original `AsyncSequence`.
|
||||
@@ -26,6 +27,7 @@ extension AsyncSequence {
|
||||
///
|
||||
/// - Returns: An `AsyncSequence` where the element is a tuple of two adjacent elements
|
||||
/// or the original `AsyncSequence`.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func adjacentPairs() -> AsyncAdjacentPairsSequence<Self> {
|
||||
AsyncAdjacentPairsSequence(self)
|
||||
@@ -34,6 +36,7 @@ extension AsyncSequence {
|
||||
|
||||
/// An `AsyncSequence` that iterates over the adjacent pairs of the original
|
||||
/// `AsyncSequence`.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncAdjacentPairsSequence<Base: AsyncSequence>: AsyncSequence {
|
||||
public typealias Element = (Base.Element, Base.Element)
|
||||
@@ -83,7 +86,8 @@ public struct AsyncAdjacentPairsSequence<Base: AsyncSequence>: AsyncSequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncAdjacentPairsSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncAdjacentPairsSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncAdjacentPairsSequence.Iterator: Sendable { }
|
||||
extension AsyncAdjacentPairsSequence.Iterator: Sendable {}
|
||||
@@ -1,10 +1,10 @@
|
||||
# AsyncBufferedByteIterator
|
||||
|
||||
Provides a highly efficient iterator useful for iterating byte sequences derived from asynchronous read functions.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncBufferedByteIterator.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestBufferedByteIterator.swift)]
|
||||
|
||||
Provides a highly efficient iterator useful for iterating byte sequences derived from asynchronous read functions.
|
||||
|
||||
This type provides infrastructure for creating `AsyncSequence` types with an `Element` of `UInt8` backed by file descriptors or similar read sources.
|
||||
|
||||
```swift
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
# Chain
|
||||
|
||||
Chains two or more asynchronous sequences together sequentially.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncChain2Sequence.swift), [Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncChain3Sequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestChain.swift)]
|
||||
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
# Combine Latest
|
||||
|
||||
Combines the latest values produced from two or more asynchronous sequences into an asynchronous sequence of tuples.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest2Sequence.swift), [Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest3Sequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestCombineLatest.swift)]
|
||||
|
||||
Combines the latest values produced from two or more asynchronous sequences into an asynchronous sequence of tuples.
|
||||
|
||||
```swift
|
||||
let appleFeed = URL("http://www.example.com/ticker?symbol=AAPL").lines
|
||||
let nasdaqFeed = URL("http://www.example.com/ticker?symbol=^IXIC").lines
|
||||
|
||||
@@ -1,3 +1,7 @@
|
||||
# Effects
|
||||
|
||||
Lists the effects of all async algorithms.
|
||||
|
||||
| Type | Throws | Sendability |
|
||||
|-----------------------------------------------------|--------------|-------------|
|
||||
| `AsyncAdjacentPairsSequence` | rethrows | Conditional |
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
# Intersperse
|
||||
|
||||
Places a given value in between each element of the asynchronous sequence.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncInterspersedSequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestInterspersed.swift)]
|
||||
|
||||
Places a given value in between each element of the asynchronous sequence.
|
||||
|
||||
```swift
|
||||
let numbers = [1, 2, 3].async.interspersed(with: 0)
|
||||
for await number in numbers {
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
# AsyncSyncSequence
|
||||
|
||||
This operation is available for all `Sequence` types.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)]
|
||||
|
||||
Converts a non-asynchronous sequence into an asynchronous one.
|
||||
|
||||
This operation is available for all `Sequence` types.
|
||||
|
||||
```swift
|
||||
let numbers = [1, 2, 3, 4].async
|
||||
let characters = "abcde".async
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
# Merge
|
||||
|
||||
Merges two or more asynchronous sequences sharing the same element type into one singular asynchronous sequence.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/Merge/AsyncMerge2Sequence.swift), [Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/Merge/AsyncMerge3Sequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestMerge.swift)]
|
||||
|
||||
Merges two or more asynchronous sequences sharing the same element type into one singular asynchronous sequence.
|
||||
|
||||
```swift
|
||||
let appleFeed = URL(string: "http://www.example.com/ticker?symbol=AAPL")!.lines.map { "AAPL: " + $0 }
|
||||
let nasdaqFeed = URL(string:"http://www.example.com/ticker?symbol=^IXIC")!.lines.map { "^IXIC: " + $0 }
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
# Zip
|
||||
|
||||
Combines the latest values produced from two or more asynchronous sequences into an asynchronous sequence of tuples.
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/Zip/AsyncZip2Sequence.swift), [Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/Zip/AsyncZip3Sequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestZip.swift)]
|
||||
|
||||
Combines the latest values produced from two or more asynchronous sequences into an asynchronous sequence of tuples.
|
||||
|
||||
```swift
|
||||
let appleFeed = URL(string: "http://www.example.com/ticker?symbol=AAPL")!.lines
|
||||
let nasdaqFeed = URL(string: "http://www.example.com/ticker?symbol=^IXIC")!.lines
|
||||
|
||||
@@ -39,10 +39,11 @@
|
||||
/// }
|
||||
///
|
||||
///
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncBufferedByteIterator: AsyncIteratorProtocol {
|
||||
public typealias Element = UInt8
|
||||
@usableFromInline var buffer: _AsyncBytesBuffer
|
||||
|
||||
|
||||
/// Creates an asynchronous buffered byte iterator with a specified capacity and read function.
|
||||
///
|
||||
/// - Parameters:
|
||||
@@ -55,7 +56,7 @@ public struct AsyncBufferedByteIterator: AsyncIteratorProtocol {
|
||||
) {
|
||||
buffer = _AsyncBytesBuffer(capacity: capacity, readFunction: readFunction)
|
||||
}
|
||||
|
||||
|
||||
/// Reads a byte out of the buffer if available. When no bytes are available, this will trigger
|
||||
/// the read function to reload the buffer and then return the next byte from that buffer.
|
||||
@inlinable @inline(__always)
|
||||
@@ -65,14 +66,15 @@ public struct AsyncBufferedByteIterator: AsyncIteratorProtocol {
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncBufferedByteIterator: Sendable { }
|
||||
extension AsyncBufferedByteIterator: Sendable {}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen @usableFromInline
|
||||
internal struct _AsyncBytesBuffer {
|
||||
@usableFromInline
|
||||
final class Storage {
|
||||
fileprivate let buffer: UnsafeMutableRawBufferPointer
|
||||
|
||||
|
||||
init(
|
||||
capacity: Int
|
||||
) {
|
||||
@@ -82,19 +84,19 @@ internal struct _AsyncBytesBuffer {
|
||||
alignment: MemoryLayout<AnyObject>.alignment
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
deinit {
|
||||
buffer.deallocate()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline internal let storage: Storage
|
||||
@usableFromInline internal var nextPointer: UnsafeRawPointer
|
||||
@usableFromInline internal var endPointer: UnsafeRawPointer
|
||||
|
||||
|
||||
internal let readFunction: @Sendable (UnsafeMutableRawBufferPointer) async throws -> Int
|
||||
internal var finished = false
|
||||
|
||||
|
||||
@usableFromInline init(
|
||||
capacity: Int,
|
||||
readFunction: @Sendable @escaping (UnsafeMutableRawBufferPointer) async throws -> Int
|
||||
@@ -105,7 +107,7 @@ internal struct _AsyncBytesBuffer {
|
||||
nextPointer = UnsafeRawPointer(s.buffer.baseAddress!)
|
||||
endPointer = nextPointer
|
||||
}
|
||||
|
||||
|
||||
@inline(never) @usableFromInline
|
||||
internal mutating func reloadBufferAndNext() async throws -> UInt8? {
|
||||
if finished {
|
||||
@@ -128,7 +130,7 @@ internal struct _AsyncBytesBuffer {
|
||||
}
|
||||
return try await next()
|
||||
}
|
||||
|
||||
|
||||
@inlinable @inline(__always)
|
||||
internal mutating func next() async throws -> UInt8? {
|
||||
if _fastPath(nextPointer != endPointer) {
|
||||
|
||||
@@ -17,20 +17,25 @@
|
||||
/// - s2: The second asynchronous sequence.
|
||||
/// - Returns: An asynchronous sequence that iterates first over the elements of `s1`, and
|
||||
/// then over the elements of `s2`.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chain<Base1: AsyncSequence, Base2: AsyncSequence>(_ s1: Base1, _ s2: Base2) -> AsyncChain2Sequence<Base1, Base2> where Base1.Element == Base2.Element {
|
||||
public func chain<Base1: AsyncSequence, Base2: AsyncSequence>(
|
||||
_ s1: Base1,
|
||||
_ s2: Base2
|
||||
) -> AsyncChain2Sequence<Base1, Base2> where Base1.Element == Base2.Element {
|
||||
AsyncChain2Sequence(s1, s2)
|
||||
}
|
||||
|
||||
/// A concatenation of two asynchronous sequences with the same element type.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncChain2Sequence<Base1: AsyncSequence, Base2: AsyncSequence> where Base1.Element == Base2.Element {
|
||||
@usableFromInline
|
||||
let base1: Base1
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let base2: Base2
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ base1: Base1, _ base2: Base2) {
|
||||
self.base1 = base1
|
||||
@@ -38,24 +43,26 @@ public struct AsyncChain2Sequence<Base1: AsyncSequence, Base2: AsyncSequence> wh
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChain2Sequence: AsyncSequence {
|
||||
public typealias Element = Base1.Element
|
||||
|
||||
|
||||
/// The iterator for a `AsyncChain2Sequence` instance.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
var base1: Base1.AsyncIterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
var base2: Base2.AsyncIterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ base1: Base1.AsyncIterator, _ base2: Base2.AsyncIterator) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
do {
|
||||
@@ -72,14 +79,16 @@ extension AsyncChain2Sequence: AsyncSequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base1.makeAsyncIterator(), base2.makeAsyncIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncChain2Sequence: Sendable where Base1: Sendable, Base2: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChain2Sequence: Sendable where Base1: Sendable, Base2: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChain2Sequence.Iterator: Sendable { }
|
||||
extension AsyncChain2Sequence.Iterator: Sendable {}
|
||||
@@ -18,23 +18,30 @@
|
||||
/// - s3: The third asynchronous sequence.
|
||||
/// - Returns: An asynchronous sequence that iterates first over the elements of `s1`, and
|
||||
/// then over the elements of `s2`, and then over the elements of `s3`
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chain<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>(_ s1: Base1, _ s2: Base2, _ s3: Base3) -> AsyncChain3Sequence<Base1, Base2, Base3> {
|
||||
public func chain<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>(
|
||||
_ s1: Base1,
|
||||
_ s2: Base2,
|
||||
_ s3: Base3
|
||||
) -> AsyncChain3Sequence<Base1, Base2, Base3> {
|
||||
AsyncChain3Sequence(s1, s2, s3)
|
||||
}
|
||||
|
||||
/// A concatenation of three asynchronous sequences with the same element type.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncChain3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence> where Base1.Element == Base2.Element, Base1.Element == Base3.Element {
|
||||
public struct AsyncChain3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>
|
||||
where Base1.Element == Base2.Element, Base1.Element == Base3.Element {
|
||||
@usableFromInline
|
||||
let base1: Base1
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let base2: Base2
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let base3: Base3
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ base1: Base1, _ base2: Base2, _ base3: Base3) {
|
||||
self.base1 = base1
|
||||
@@ -43,28 +50,30 @@ public struct AsyncChain3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Ba
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChain3Sequence: AsyncSequence {
|
||||
public typealias Element = Base1.Element
|
||||
|
||||
|
||||
/// The iterator for a `AsyncChain3Sequence` instance.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
var base1: Base1.AsyncIterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
var base2: Base2.AsyncIterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
var base3: Base3.AsyncIterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ base1: Base1.AsyncIterator, _ base2: Base2.AsyncIterator, _ base3: Base3.AsyncIterator) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
self.base3 = base3
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
do {
|
||||
@@ -87,14 +96,16 @@ extension AsyncChain3Sequence: AsyncSequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base1.makeAsyncIterator(), base2.makeAsyncIterator(), base3.makeAsyncIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncChain3Sequence: Sendable where Base1: Sendable, Base2: Sendable, Base3: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChain3Sequence: Sendable where Base1: Sendable, Base2: Sendable, Base3: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChain3Sequence.Iterator: Sendable { }
|
||||
extension AsyncChain3Sequence.Iterator: Sendable {}
|
||||
@@ -9,17 +9,25 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection`
|
||||
/// type by testing if elements belong in the same group.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chunked<Collected: RangeReplaceableCollection>(into: Collected.Type, by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool) -> AsyncChunkedByGroupSequence<Self, Collected> where Collected.Element == Element {
|
||||
public func chunked<Collected: RangeReplaceableCollection>(
|
||||
into: Collected.Type,
|
||||
by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool
|
||||
) -> AsyncChunkedByGroupSequence<Self, Collected> where Collected.Element == Element {
|
||||
AsyncChunkedByGroupSequence(self, grouping: belongInSameGroup)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks by testing if elements belong in the same group.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chunked(by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool) -> AsyncChunkedByGroupSequence<Self, [Element]> {
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool
|
||||
) -> AsyncChunkedByGroupSequence<Self, [Element]> {
|
||||
chunked(into: [Element].self, by: belongInSameGroup)
|
||||
}
|
||||
}
|
||||
@@ -46,7 +54,9 @@ extension AsyncSequence {
|
||||
/// // [10, 20, 30]
|
||||
/// // [10, 40, 40]
|
||||
/// // [10, 20]
|
||||
public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence
|
||||
where Collected.Element == Base.Element {
|
||||
public typealias Element = Collected
|
||||
|
||||
/// The iterator for a `AsyncChunkedByGroupSequence` instance.
|
||||
@@ -76,7 +86,7 @@ public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeR
|
||||
} else {
|
||||
hangingNext = nil
|
||||
}
|
||||
|
||||
|
||||
guard let first = firstOpt else {
|
||||
return nil
|
||||
}
|
||||
@@ -86,23 +96,22 @@ public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeR
|
||||
|
||||
var prev = first
|
||||
while let next = try await base.next() {
|
||||
if grouping(prev, next) {
|
||||
result.append(next)
|
||||
prev = next
|
||||
} else {
|
||||
guard grouping(prev, next) else {
|
||||
hangingNext = next
|
||||
break
|
||||
}
|
||||
result.append(next)
|
||||
prev = next
|
||||
}
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
let base : Base
|
||||
let base: Base
|
||||
|
||||
@usableFromInline
|
||||
let grouping : @Sendable (Base.Element, Base.Element) -> Bool
|
||||
let grouping: @Sendable (Base.Element, Base.Element) -> Bool
|
||||
|
||||
@usableFromInline
|
||||
init(_ base: Base, grouping: @escaping @Sendable (Base.Element, Base.Element) -> Bool) {
|
||||
@@ -116,7 +125,8 @@ public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeR
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncChunkedByGroupSequence : Sendable where Base : Sendable, Base.Element : Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChunkedByGroupSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChunkedByGroupSequence.Iterator: Sendable { }
|
||||
extension AsyncChunkedByGroupSequence.Iterator: Sendable {}
|
||||
@@ -9,22 +9,35 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection` type on the uniqueness of a given subject.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chunked<Subject : Equatable, Collected: RangeReplaceableCollection>(into: Collected.Type, on projection: @escaping @Sendable (Element) -> Subject) -> AsyncChunkedOnProjectionSequence<Self, Subject, Collected> {
|
||||
public func chunked<Subject: Equatable, Collected: RangeReplaceableCollection>(
|
||||
into: Collected.Type,
|
||||
on projection: @escaping @Sendable (Element) -> Subject
|
||||
) -> AsyncChunkedOnProjectionSequence<Self, Subject, Collected> {
|
||||
AsyncChunkedOnProjectionSequence(self, projection: projection)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks on the uniqueness of a given subject.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chunked<Subject : Equatable>(on projection: @escaping @Sendable (Element) -> Subject) -> AsyncChunkedOnProjectionSequence<Self, Subject, [Element]> {
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping @Sendable (Element) -> Subject
|
||||
) -> AsyncChunkedOnProjectionSequence<Self, Subject, [Element]> {
|
||||
chunked(into: [Element].self, on: projection)
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that chunks on a subject when it differs from the last element.
|
||||
public struct AsyncChunkedOnProjectionSequence<Base: AsyncSequence, Subject: Equatable, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncChunkedOnProjectionSequence<
|
||||
Base: AsyncSequence,
|
||||
Subject: Equatable,
|
||||
Collected: RangeReplaceableCollection
|
||||
>: AsyncSequence where Collected.Element == Base.Element {
|
||||
public typealias Element = (Subject, Collected)
|
||||
|
||||
/// The iterator for a `AsyncChunkedOnProjectionSequence` instance.
|
||||
@@ -67,22 +80,21 @@ public struct AsyncChunkedOnProjectionSequence<Base: AsyncSequence, Subject: Equ
|
||||
|
||||
while let next = try await base.next() {
|
||||
let subj = projection(next)
|
||||
if subj == first.0 {
|
||||
result.append(next)
|
||||
} else {
|
||||
guard subj == first.0 else {
|
||||
hangingNext = (subj, next)
|
||||
break
|
||||
}
|
||||
result.append(next)
|
||||
}
|
||||
return (first.0, result)
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
let base : Base
|
||||
let base: Base
|
||||
|
||||
@usableFromInline
|
||||
let projection : @Sendable (Base.Element) -> Subject
|
||||
let projection: @Sendable (Base.Element) -> Subject
|
||||
|
||||
@usableFromInline
|
||||
init(_ base: Base, projection: @escaping @Sendable (Base.Element) -> Subject) {
|
||||
@@ -96,7 +108,8 @@ public struct AsyncChunkedOnProjectionSequence<Base: AsyncSequence, Subject: Equ
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncChunkedOnProjectionSequence : Sendable where Base : Sendable, Base.Element : Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChunkedOnProjectionSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChunkedOnProjectionSequence.Iterator: Sendable { }
|
||||
extension AsyncChunkedOnProjectionSequence.Iterator: Sendable {}
|
||||
@@ -9,54 +9,93 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection` type of a given count or when a signal `AsyncSequence` produces an element.
|
||||
public func chunks<Signal, Collected: RangeReplaceableCollection>(ofCount count: Int, or signal: Signal, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func chunks<Signal, Collected: RangeReplaceableCollection>(
|
||||
ofCount count: Int,
|
||||
or signal: Signal,
|
||||
into: Collected.Type
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
|
||||
AsyncChunksOfCountOrSignalSequence(self, count: count, signal: signal)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks of a given count or when a signal `AsyncSequence` produces an element.
|
||||
public func chunks<Signal>(ofCount count: Int, or signal: Signal) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func chunks<Signal>(
|
||||
ofCount count: Int,
|
||||
or signal: Signal
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {
|
||||
chunks(ofCount: count, or: signal, into: [Element].self)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection` type when a signal `AsyncSequence` produces an element.
|
||||
public func chunked<Signal, Collected: RangeReplaceableCollection>(by signal: Signal, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func chunked<Signal, Collected: RangeReplaceableCollection>(
|
||||
by signal: Signal,
|
||||
into: Collected.Type
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
|
||||
AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: signal)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks when a signal `AsyncSequence` produces an element.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func chunked<Signal>(by signal: Signal) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {
|
||||
chunked(by: signal, into: [Element].self)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection` type of a given count or when an `AsyncTimerSequence` fires.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
|
||||
public func chunks<C: Clock, Collected: RangeReplaceableCollection>(
|
||||
ofCount count: Int,
|
||||
or timer: AsyncTimerSequence<C>,
|
||||
into: Collected.Type
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
|
||||
AsyncChunksOfCountOrSignalSequence(self, count: count, signal: timer)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks of a given count or when an `AsyncTimerSequence` fires.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
|
||||
public func chunks<C: Clock>(
|
||||
ofCount count: Int,
|
||||
or timer: AsyncTimerSequence<C>
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
|
||||
chunks(ofCount: count, or: timer, into: [Element].self)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection` type when an `AsyncTimerSequence` fires.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
|
||||
public func chunked<C: Clock, Collected: RangeReplaceableCollection>(
|
||||
by timer: AsyncTimerSequence<C>,
|
||||
into: Collected.Type
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
|
||||
AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: timer)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks when an `AsyncTimerSequence` fires.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
|
||||
public func chunked<C: Clock>(
|
||||
by timer: AsyncTimerSequence<C>
|
||||
) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
|
||||
chunked(by: timer, into: [Element].self)
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that chunks elements into collected `RangeReplaceableCollection` instances by either count or a signal from another `AsyncSequence`.
|
||||
public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection, Signal: AsyncSequence>: AsyncSequence, Sendable where Collected.Element == Base.Element, Base: Sendable, Signal: Sendable, Base.Element: Sendable, Signal.Element: Sendable {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncChunksOfCountOrSignalSequence<
|
||||
Base: AsyncSequence,
|
||||
Collected: RangeReplaceableCollection,
|
||||
Signal: AsyncSequence
|
||||
>: AsyncSequence, Sendable
|
||||
where
|
||||
Collected.Element == Base.Element,
|
||||
Base: Sendable,
|
||||
Signal: Sendable,
|
||||
Base.Element: Sendable,
|
||||
Signal.Element: Sendable
|
||||
{
|
||||
|
||||
public typealias Element = Collected
|
||||
|
||||
@@ -65,23 +104,23 @@ public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected:
|
||||
case terminal
|
||||
case signal
|
||||
}
|
||||
|
||||
|
||||
/// The iterator for a `AsyncChunksOfCountOrSignalSequence` instance.
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
typealias EitherMappedBase = AsyncMapSequence<Base, Either>
|
||||
typealias EitherMappedSignal = AsyncMapSequence<Signal, Either>
|
||||
typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncSyncSequence<[Either]>>
|
||||
typealias Merged = AsyncMerge2Sequence<ChainedBase, EitherMappedSignal>
|
||||
|
||||
|
||||
let count: Int?
|
||||
var iterator: Merged.AsyncIterator
|
||||
var terminated = false
|
||||
|
||||
|
||||
init(iterator: Merged.AsyncIterator, count: Int?) {
|
||||
self.count = count
|
||||
self.iterator = iterator
|
||||
}
|
||||
|
||||
|
||||
public mutating func next() async rethrows -> Collected? {
|
||||
guard !terminated else {
|
||||
return nil
|
||||
@@ -124,10 +163,16 @@ public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected:
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
|
||||
return Iterator(iterator: merge(chain(base.map { Either.element($0) }, [.terminal].async), signal.map { _ in Either.signal }).makeAsyncIterator(), count: count)
|
||||
|
||||
return Iterator(
|
||||
iterator: merge(
|
||||
chain(base.map { Either.element($0) }, [.terminal].async),
|
||||
signal.map { _ in Either.signal }
|
||||
).makeAsyncIterator(),
|
||||
count: count
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChunksOfCountOrSignalSequence.Iterator: Sendable { }
|
||||
extension AsyncChunksOfCountOrSignalSequence.Iterator: Sendable {}
|
||||
@@ -9,14 +9,20 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Creates an asynchronous sequence that creates chunks of a given `RangeReplaceableCollection` of a given count.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chunks<Collected: RangeReplaceableCollection>(ofCount count: Int, into: Collected.Type) -> AsyncChunksOfCountSequence<Self, Collected> where Collected.Element == Element {
|
||||
public func chunks<Collected: RangeReplaceableCollection>(
|
||||
ofCount count: Int,
|
||||
into: Collected.Type
|
||||
) -> AsyncChunksOfCountSequence<Self, Collected> where Collected.Element == Element {
|
||||
AsyncChunksOfCountSequence(self, count: count)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that creates chunks of a given count.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func chunks(ofCount count: Int) -> AsyncChunksOfCountSequence<Self, [Element]> {
|
||||
chunks(ofCount: count, into: [Element].self)
|
||||
@@ -24,7 +30,9 @@ extension AsyncSequence {
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that chunks elements into `RangeReplaceableCollection` instances of at least a given count.
|
||||
public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence
|
||||
where Collected.Element == Base.Element {
|
||||
public typealias Element = Collected
|
||||
|
||||
/// The iterator for a `AsyncChunksOfCountSequence` instance.
|
||||
@@ -67,10 +75,10 @@ public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeRe
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
let base : Base
|
||||
let base: Base
|
||||
|
||||
@usableFromInline
|
||||
let count : Int
|
||||
let count: Int
|
||||
|
||||
@usableFromInline
|
||||
init(_ base: Base, count: Int) {
|
||||
@@ -85,8 +93,7 @@ public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeRe
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncChunksOfCountSequence : Sendable where Base : Sendable, Base.Element : Sendable { }
|
||||
extension AsyncChunksOfCountSequence.Iterator : Sendable where Base.AsyncIterator : Sendable, Base.Element : Sendable { }
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChunksOfCountSequence.Iterator: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChunksOfCountSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncChunksOfCountSequence.Iterator: Sendable where Base.AsyncIterator: Sendable, Base.Element: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Returns a new `AsyncSequence` that iterates over every non-nil element from the
|
||||
/// original `AsyncSequence`.
|
||||
@@ -18,22 +19,24 @@ extension AsyncSequence {
|
||||
/// - Returns: An `AsyncSequence` where the element is the unwrapped original
|
||||
/// element and iterates over every non-nil element from the original
|
||||
/// `AsyncSequence`.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> AsyncCompactedSequence<Self, Unwrapped>
|
||||
where Element == Unwrapped? {
|
||||
where Element == Unwrapped? {
|
||||
AsyncCompactedSequence(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that iterates over every non-nil element from the original
|
||||
/// `AsyncSequence`.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncCompactedSequence<Base: AsyncSequence, Element>: AsyncSequence
|
||||
where Base.Element == Element? {
|
||||
where Base.Element == Element? {
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ base: Base) {
|
||||
self.base = base
|
||||
@@ -44,12 +47,12 @@ public struct AsyncCompactedSequence<Base: AsyncSequence, Element>: AsyncSequenc
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
var base: Base.AsyncIterator
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ base: Base.AsyncIterator) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
while let wrapped = try await base.next() {
|
||||
@@ -66,7 +69,8 @@ public struct AsyncCompactedSequence<Base: AsyncSequence, Element>: AsyncSequenc
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncCompactedSequence.Iterator: Sendable { }
|
||||
extension AsyncCompactedSequence.Iterator: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Returns an asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using the given closure.
|
||||
@@ -22,13 +23,17 @@ extension AsyncSequence {
|
||||
/// the next element in the receiving asynchronous sequence, which it returns.
|
||||
/// - Returns: An asynchronous sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func reductions<Result>(_ initial: Result, _ transform: @Sendable @escaping (Result, Element) async -> Result) -> AsyncExclusiveReductionsSequence<Self, Result> {
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @Sendable @escaping (Result, Element) async -> Result
|
||||
) -> AsyncExclusiveReductionsSequence<Self, Result> {
|
||||
reductions(into: initial) { result, element in
|
||||
result = await transform(result, element)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Returns an asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using the given closure.
|
||||
///
|
||||
@@ -42,25 +47,30 @@ extension AsyncSequence {
|
||||
/// previous result instead of returning a value.
|
||||
/// - Returns: An asynchronous sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func reductions<Result>(into initial: Result, _ transform: @Sendable @escaping (inout Result, Element) async -> Void) -> AsyncExclusiveReductionsSequence<Self, Result> {
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @Sendable @escaping (inout Result, Element) async -> Void
|
||||
) -> AsyncExclusiveReductionsSequence<Self, Result> {
|
||||
AsyncExclusiveReductionsSequence(self, initial: initial, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
/// An asynchronous sequence of applying a transform to the element of an asynchronous sequence and the
|
||||
/// previously transformed result.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncExclusiveReductionsSequence<Base: AsyncSequence, Element> {
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let initial: Element
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let transform: @Sendable (inout Element, Base.Element) async -> Void
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ base: Base, initial: Element, transform: @Sendable @escaping (inout Element, Base.Element) async -> Void) {
|
||||
self.base = base
|
||||
@@ -69,49 +79,55 @@ public struct AsyncExclusiveReductionsSequence<Base: AsyncSequence, Element> {
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncExclusiveReductionsSequence: AsyncSequence {
|
||||
/// The iterator for an `AsyncExclusiveReductionsSequence` instance.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
var iterator: Base.AsyncIterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
var current: Element?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let transform: @Sendable (inout Element, Base.Element) async -> Void
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ iterator: Base.AsyncIterator, initial: Element, transform: @Sendable @escaping (inout Element, Base.Element) async -> Void) {
|
||||
init(
|
||||
_ iterator: Base.AsyncIterator,
|
||||
initial: Element,
|
||||
transform: @Sendable @escaping (inout Element, Base.Element) async -> Void
|
||||
) {
|
||||
self.iterator = iterator
|
||||
self.current = initial
|
||||
self.transform = transform
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
guard let result = current else { return nil }
|
||||
guard var result = current else { return nil }
|
||||
let value = try await iterator.next()
|
||||
if let value = value {
|
||||
var result = result
|
||||
await transform(&result, value)
|
||||
current = result
|
||||
return result
|
||||
} else {
|
||||
guard let value = value else {
|
||||
current = nil
|
||||
return nil
|
||||
}
|
||||
await transform(&result, value)
|
||||
current = result
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base.makeAsyncIterator(), initial: initial, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncExclusiveReductionsSequence: Sendable where Base: Sendable, Element: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncExclusiveReductionsSequence: Sendable where Base: Sendable, Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncExclusiveReductionsSequence.Iterator: Sendable { }
|
||||
extension AsyncExclusiveReductionsSequence.Iterator: Sendable {}
|
||||
@@ -1,3 +1,15 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Returns an asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using the given closure.
|
||||
@@ -17,6 +29,7 @@ extension AsyncSequence {
|
||||
/// result and the next element in the receiving sequence, and returns
|
||||
/// the result.
|
||||
/// - Returns: An asynchronous sequence of the reduced elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func reductions(
|
||||
_ transform: @Sendable @escaping (Element, Element) async -> Element
|
||||
@@ -27,14 +40,15 @@ extension AsyncSequence {
|
||||
|
||||
/// An asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using a given closure.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncInclusiveReductionsSequence<Base: AsyncSequence> {
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let transform: @Sendable (Base.Element, Base.Element) async -> Base.Element
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ base: Base, transform: @Sendable @escaping (Base.Element, Base.Element) async -> Base.Element) {
|
||||
self.base = base
|
||||
@@ -42,10 +56,12 @@ public struct AsyncInclusiveReductionsSequence<Base: AsyncSequence> {
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncInclusiveReductionsSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
|
||||
/// The iterator for an `AsyncInclusiveReductionsSequence` instance.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
@@ -78,13 +94,15 @@ extension AsyncInclusiveReductionsSequence: AsyncSequence {
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base.makeAsyncIterator(), transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncInclusiveReductionsSequence: Sendable where Base: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncInclusiveReductionsSequence: Sendable where Base: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncInclusiveReductionsSequence.Iterator: Sendable { }
|
||||
extension AsyncInclusiveReductionsSequence.Iterator: Sendable {}
|
||||
@@ -9,16 +9,22 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence where Element: AsyncSequence {
|
||||
/// Concatenate an `AsyncSequence` of `AsyncSequence` elements with a separator.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func joined<Separator: AsyncSequence>(separator: Separator) -> AsyncJoinedBySeparatorSequence<Self, Separator> {
|
||||
public func joined<Separator: AsyncSequence>(
|
||||
separator: Separator
|
||||
) -> AsyncJoinedBySeparatorSequence<Self, Separator> {
|
||||
return AsyncJoinedBySeparatorSequence(self, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that concatenates `AsyncSequence` elements with a separator.
|
||||
public struct AsyncJoinedBySeparatorSequence<Base: AsyncSequence, Separator: AsyncSequence>: AsyncSequence where Base.Element: AsyncSequence, Separator.Element == Base.Element.Element {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncJoinedBySeparatorSequence<Base: AsyncSequence, Separator: AsyncSequence>: AsyncSequence
|
||||
where Base.Element: AsyncSequence, Separator.Element == Base.Element.Element {
|
||||
public typealias Element = Base.Element.Element
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
@@ -36,31 +42,31 @@ public struct AsyncJoinedBySeparatorSequence<Base: AsyncSequence, Separator: Asy
|
||||
@usableFromInline
|
||||
func startSeparator() -> SeparatorState {
|
||||
switch self {
|
||||
case .initial(let separatorSequence):
|
||||
return .partialAsync(separatorSequence.makeAsyncIterator(), [])
|
||||
case .cached(let array):
|
||||
return .partialCached(array.makeIterator(), array)
|
||||
default:
|
||||
fatalError("Invalid separator sequence state")
|
||||
case .initial(let separatorSequence):
|
||||
return .partialAsync(separatorSequence.makeAsyncIterator(), [])
|
||||
case .cached(let array):
|
||||
return .partialCached(array.makeIterator(), array)
|
||||
default:
|
||||
fatalError("Invalid separator sequence state")
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
func next() async rethrows -> (Element?, SeparatorState) {
|
||||
switch self {
|
||||
case .partialAsync(var separatorIterator, var cache):
|
||||
guard let next = try await separatorIterator.next() else {
|
||||
return (nil, .cached(cache))
|
||||
}
|
||||
cache.append(next)
|
||||
return (next, .partialAsync(separatorIterator, cache))
|
||||
case .partialCached(var cacheIterator, let cache):
|
||||
guard let next = cacheIterator.next() else {
|
||||
return (nil, .cached(cache))
|
||||
}
|
||||
return (next, .partialCached(cacheIterator, cache))
|
||||
default:
|
||||
fatalError("Invalid separator sequence state")
|
||||
case .partialAsync(var separatorIterator, var cache):
|
||||
guard let next = try await separatorIterator.next() else {
|
||||
return (nil, .cached(cache))
|
||||
}
|
||||
cache.append(next)
|
||||
return (next, .partialAsync(separatorIterator, cache))
|
||||
case .partialCached(var cacheIterator, let cache):
|
||||
guard let next = cacheIterator.next() else {
|
||||
return (nil, .cached(cache))
|
||||
}
|
||||
return (next, .partialCached(cacheIterator, cache))
|
||||
default:
|
||||
fatalError("Invalid separator sequence state")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -83,37 +89,37 @@ public struct AsyncJoinedBySeparatorSequence<Base: AsyncSequence, Separator: Asy
|
||||
public mutating func next() async rethrows -> Base.Element.Element? {
|
||||
do {
|
||||
switch state {
|
||||
case .terminal:
|
||||
case .terminal:
|
||||
return nil
|
||||
case .initial(var outerIterator, let separator):
|
||||
guard let innerSequence = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
case .initial(var outerIterator, let separator):
|
||||
guard let innerSequence = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
}
|
||||
let innerIterator = innerSequence.makeAsyncIterator()
|
||||
state = .sequence(outerIterator, innerIterator, .initial(separator))
|
||||
return try await next()
|
||||
case .sequence(var outerIterator, var innerIterator, let separatorState):
|
||||
if let item = try await innerIterator.next() {
|
||||
state = .sequence(outerIterator, innerIterator, separatorState)
|
||||
return item
|
||||
}
|
||||
|
||||
guard let nextInner = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
}
|
||||
|
||||
state = .separator(outerIterator, separatorState.startSeparator(), nextInner)
|
||||
return try await next()
|
||||
case .separator(let iterator, let separatorState, let nextBase):
|
||||
let (itemOpt, newSepState) = try await separatorState.next()
|
||||
guard let item = itemOpt else {
|
||||
state = .sequence(iterator, nextBase.makeAsyncIterator(), newSepState)
|
||||
return try await next()
|
||||
}
|
||||
state = .separator(iterator, newSepState, nextBase)
|
||||
}
|
||||
let innerIterator = innerSequence.makeAsyncIterator()
|
||||
state = .sequence(outerIterator, innerIterator, .initial(separator))
|
||||
return try await next()
|
||||
case .sequence(var outerIterator, var innerIterator, let separatorState):
|
||||
if let item = try await innerIterator.next() {
|
||||
state = .sequence(outerIterator, innerIterator, separatorState)
|
||||
return item
|
||||
}
|
||||
|
||||
guard let nextInner = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
}
|
||||
|
||||
state = .separator(outerIterator, separatorState.startSeparator(), nextInner)
|
||||
return try await next()
|
||||
case .separator(let iterator, let separatorState, let nextBase):
|
||||
let (itemOpt, newSepState) = try await separatorState.next()
|
||||
guard let item = itemOpt else {
|
||||
state = .sequence(iterator, nextBase.makeAsyncIterator(), newSepState)
|
||||
return try await next()
|
||||
}
|
||||
state = .separator(iterator, newSepState, nextBase)
|
||||
return item
|
||||
}
|
||||
} catch {
|
||||
state = .terminal
|
||||
@@ -140,8 +146,9 @@ public struct AsyncJoinedBySeparatorSequence<Base: AsyncSequence, Separator: Asy
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncJoinedBySeparatorSequence: Sendable
|
||||
where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable, Separator: Sendable { }
|
||||
where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable, Separator: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncJoinedBySeparatorSequence.Iterator: Sendable { }
|
||||
extension AsyncJoinedBySeparatorSequence.Iterator: Sendable {}
|
||||
@@ -9,8 +9,10 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence where Element: AsyncSequence {
|
||||
/// Concatenate an `AsyncSequence` of `AsyncSequence` elements
|
||||
/// Concatenate an `AsyncSequence` of `AsyncSequence` elements
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func joined() -> AsyncJoinedSequence<Self> {
|
||||
return AsyncJoinedSequence(self)
|
||||
@@ -18,6 +20,7 @@ extension AsyncSequence where Element: AsyncSequence {
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that concatenates`AsyncSequence` elements
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncJoinedSequence<Base: AsyncSequence>: AsyncSequence where Base.Element: AsyncSequence {
|
||||
public typealias Element = Base.Element.Element
|
||||
@@ -32,42 +35,42 @@ public struct AsyncJoinedSequence<Base: AsyncSequence>: AsyncSequence where Base
|
||||
case sequence(Base.AsyncIterator, Base.Element.AsyncIterator)
|
||||
case terminal
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
var state: State
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ iterator: Base.AsyncIterator) {
|
||||
state = .initial(iterator)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async rethrows -> Base.Element.Element? {
|
||||
do {
|
||||
switch state {
|
||||
case .terminal:
|
||||
case .terminal:
|
||||
return nil
|
||||
case .initial(var outerIterator):
|
||||
guard let innerSequence = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
case .initial(var outerIterator):
|
||||
guard let innerSequence = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
}
|
||||
let innerIterator = innerSequence.makeAsyncIterator()
|
||||
}
|
||||
let innerIterator = innerSequence.makeAsyncIterator()
|
||||
state = .sequence(outerIterator, innerIterator)
|
||||
return try await next()
|
||||
case .sequence(var outerIterator, var innerIterator):
|
||||
if let item = try await innerIterator.next() {
|
||||
state = .sequence(outerIterator, innerIterator)
|
||||
return try await next()
|
||||
case .sequence(var outerIterator, var innerIterator):
|
||||
if let item = try await innerIterator.next() {
|
||||
state = .sequence(outerIterator, innerIterator)
|
||||
return item
|
||||
}
|
||||
|
||||
guard let nextInner = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
}
|
||||
return item
|
||||
}
|
||||
|
||||
state = .sequence(outerIterator, nextInner.makeAsyncIterator())
|
||||
return try await next()
|
||||
guard let nextInner = try await outerIterator.next() else {
|
||||
state = .terminal
|
||||
return nil
|
||||
}
|
||||
|
||||
state = .sequence(outerIterator, nextInner.makeAsyncIterator())
|
||||
return try await next()
|
||||
}
|
||||
} catch {
|
||||
state = .terminal
|
||||
@@ -75,23 +78,24 @@ public struct AsyncJoinedSequence<Base: AsyncSequence>: AsyncSequence where Base
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ base: Base) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
return Iterator(base.makeAsyncIterator())
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncJoinedSequence: Sendable
|
||||
where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable { }
|
||||
where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncJoinedSequence.Iterator: Sendable { }
|
||||
extension AsyncJoinedSequence.Iterator: Sendable {}
|
||||
@@ -9,8 +9,10 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence where Element: Equatable {
|
||||
/// Creates an asynchronous sequence that omits repeated elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func removeDuplicates() -> AsyncRemoveDuplicatesSequence<Self> {
|
||||
AsyncRemoveDuplicatesSequence(self) { lhs, rhs in
|
||||
lhs == rhs
|
||||
@@ -18,19 +20,27 @@ extension AsyncSequence where Element: Equatable {
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Creates an asynchronous sequence that omits repeated elements by testing them with a predicate.
|
||||
public func removeDuplicates(by predicate: @escaping @Sendable (Element, Element) async -> Bool) -> AsyncRemoveDuplicatesSequence<Self> {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func removeDuplicates(
|
||||
by predicate: @escaping @Sendable (Element, Element) async -> Bool
|
||||
) -> AsyncRemoveDuplicatesSequence<Self> {
|
||||
return AsyncRemoveDuplicatesSequence(self, predicate: predicate)
|
||||
}
|
||||
|
||||
|
||||
/// Creates an asynchronous sequence that omits repeated elements by testing them with an error-throwing predicate.
|
||||
public func removeDuplicates(by predicate: @escaping @Sendable (Element, Element) async throws -> Bool) -> AsyncThrowingRemoveDuplicatesSequence<Self> {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func removeDuplicates(
|
||||
by predicate: @escaping @Sendable (Element, Element) async throws -> Bool
|
||||
) -> AsyncThrowingRemoveDuplicatesSequence<Self> {
|
||||
return AsyncThrowingRemoveDuplicatesSequence(self, predicate: predicate)
|
||||
}
|
||||
}
|
||||
|
||||
/// An asynchronous sequence that omits repeated elements by testing them with a predicate.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
@@ -73,7 +83,7 @@ public struct AsyncRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence
|
||||
|
||||
@usableFromInline
|
||||
let predicate: @Sendable (Element, Element) async -> Bool
|
||||
|
||||
|
||||
init(_ base: Base, predicate: @escaping @Sendable (Element, Element) async -> Bool) {
|
||||
self.base = base
|
||||
self.predicate = predicate
|
||||
@@ -86,9 +96,10 @@ public struct AsyncRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence
|
||||
}
|
||||
|
||||
/// An asynchronous sequence that omits repeated elements by testing them with an error-throwing predicate.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
|
||||
/// The iterator for an `AsyncThrowingRemoveDuplicatesSequence` instance.
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
|
||||
@@ -128,7 +139,7 @@ public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncS
|
||||
|
||||
@usableFromInline
|
||||
let predicate: @Sendable (Element, Element) async throws -> Bool
|
||||
|
||||
|
||||
init(_ base: Base, predicate: @escaping @Sendable (Element, Element) async throws -> Bool) {
|
||||
self.base = base
|
||||
self.predicate = predicate
|
||||
@@ -140,12 +151,13 @@ public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncS
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
extension AsyncRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
|
||||
extension AsyncThrowingRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncRemoveDuplicatesSequence.Iterator: Sendable { }
|
||||
extension AsyncRemoveDuplicatesSequence.Iterator: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncThrowingRemoveDuplicatesSequence.Iterator: Sendable { }
|
||||
extension AsyncThrowingRemoveDuplicatesSequence.Iterator: Sendable {}
|
||||
@@ -9,10 +9,12 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension Sequence {
|
||||
/// An asynchronous sequence containing the same elements as this sequence,
|
||||
/// but on which operations, such as `map` and `filter`, are
|
||||
/// implemented asynchronously.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public var async: AsyncSyncSequence<Self> {
|
||||
AsyncSyncSequence(self)
|
||||
@@ -27,46 +29,47 @@ extension Sequence {
|
||||
///
|
||||
/// This functions similarly to `LazySequence` by accessing elements sequentially
|
||||
/// in the iterator's `next()` method.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
var iterator: Base.Iterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ iterator: Base.Iterator) {
|
||||
self.iterator = iterator
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async -> Base.Element? {
|
||||
if !Task.isCancelled, let value = iterator?.next() {
|
||||
return value
|
||||
} else {
|
||||
guard !Task.isCancelled, let value = iterator?.next() else {
|
||||
iterator = nil
|
||||
return nil
|
||||
}
|
||||
return value
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
init(_ base: Base) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base.makeIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncSyncSequence: Sendable where Base: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSyncSequence: Sendable where Base: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncSyncSequence.Iterator: Sendable { }
|
||||
extension AsyncSyncSequence.Iterator: Sendable {}
|
||||
@@ -9,35 +9,49 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Create a rate-limited `AsyncSequence` by emitting values at most every specified interval.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func _throttle<C: Clock, Reduced>(for interval: C.Instant.Duration, clock: C, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> _AsyncThrottleSequence<Self, C, Reduced> {
|
||||
_AsyncThrottleSequence(self, interval: interval, clock: clock, reducing: reducing)
|
||||
public func _throttle<C: Clock, Reduced>(
|
||||
for interval: C.Instant.Duration,
|
||||
clock: C,
|
||||
reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced
|
||||
) -> _AsyncThrottleSequence<Self, C, Reduced> {
|
||||
_AsyncThrottleSequence(self, interval: interval, clock: clock, reducing: reducing)
|
||||
}
|
||||
|
||||
|
||||
/// Create a rate-limited `AsyncSequence` by emitting values at most every specified interval.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func _throttle<Reduced>(for interval: Duration, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> _AsyncThrottleSequence<Self, ContinuousClock, Reduced> {
|
||||
_throttle(for: interval, clock: .continuous, reducing: reducing)
|
||||
public func _throttle<Reduced>(
|
||||
for interval: Duration,
|
||||
reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced
|
||||
) -> _AsyncThrottleSequence<Self, ContinuousClock, Reduced> {
|
||||
_throttle(for: interval, clock: .continuous, reducing: reducing)
|
||||
}
|
||||
|
||||
|
||||
/// Create a rate-limited `AsyncSequence` by emitting values at most every specified interval.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func _throttle<C: Clock>(for interval: C.Instant.Duration, clock: C, latest: Bool = true) -> _AsyncThrottleSequence<Self, C, Element> {
|
||||
_throttle(for: interval, clock: clock) { previous, element in
|
||||
if latest {
|
||||
return element
|
||||
} else {
|
||||
public func _throttle<C: Clock>(
|
||||
for interval: C.Instant.Duration,
|
||||
clock: C,
|
||||
latest: Bool = true
|
||||
) -> _AsyncThrottleSequence<Self, C, Element> {
|
||||
_throttle(for: interval, clock: clock) { previous, element in
|
||||
guard latest else {
|
||||
return previous ?? element
|
||||
}
|
||||
return element
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Create a rate-limited `AsyncSequence` by emitting values at most every specified interval.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func _throttle(for interval: Duration, latest: Bool = true) -> _AsyncThrottleSequence<Self, ContinuousClock, Element> {
|
||||
_throttle(for: interval, clock: .continuous, latest: latest)
|
||||
public func _throttle(
|
||||
for interval: Duration,
|
||||
latest: Bool = true
|
||||
) -> _AsyncThrottleSequence<Self, ContinuousClock, Element> {
|
||||
_throttle(for: interval, clock: .continuous, latest: latest)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -48,8 +62,13 @@ public struct _AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {
|
||||
let interval: C.Instant.Duration
|
||||
let clock: C
|
||||
let reducing: @Sendable (Reduced?, Base.Element) async -> Reduced
|
||||
|
||||
init(_ base: Base, interval: C.Instant.Duration, clock: C, reducing: @Sendable @escaping (Reduced?, Base.Element) async -> Reduced) {
|
||||
|
||||
init(
|
||||
_ base: Base,
|
||||
interval: C.Instant.Duration,
|
||||
clock: C,
|
||||
reducing: @Sendable @escaping (Reduced?, Base.Element) async -> Reduced
|
||||
) {
|
||||
self.base = base
|
||||
self.interval = interval
|
||||
self.clock = clock
|
||||
@@ -60,7 +79,7 @@ public struct _AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension _AsyncThrottleSequence: AsyncSequence {
|
||||
public typealias Element = Reduced
|
||||
|
||||
|
||||
/// The iterator for an `AsyncThrottleSequence` instance.
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
var base: Base.AsyncIterator
|
||||
@@ -68,14 +87,19 @@ extension _AsyncThrottleSequence: AsyncSequence {
|
||||
let interval: C.Instant.Duration
|
||||
let clock: C
|
||||
let reducing: @Sendable (Reduced?, Base.Element) async -> Reduced
|
||||
|
||||
init(_ base: Base.AsyncIterator, interval: C.Instant.Duration, clock: C, reducing: @Sendable @escaping (Reduced?, Base.Element) async -> Reduced) {
|
||||
|
||||
init(
|
||||
_ base: Base.AsyncIterator,
|
||||
interval: C.Instant.Duration,
|
||||
clock: C,
|
||||
reducing: @Sendable @escaping (Reduced?, Base.Element) async -> Reduced
|
||||
) {
|
||||
self.base = base
|
||||
self.interval = interval
|
||||
self.clock = clock
|
||||
self.reducing = reducing
|
||||
}
|
||||
|
||||
|
||||
public mutating func next() async rethrows -> Reduced? {
|
||||
var reduced: Reduced?
|
||||
let start = last ?? clock.now
|
||||
@@ -103,14 +127,14 @@ extension _AsyncThrottleSequence: AsyncSequence {
|
||||
} while true
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base.makeAsyncIterator(), interval: interval, clock: clock, reducing: reducing)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension _AsyncThrottleSequence: Sendable where Base: Sendable, Element: Sendable { }
|
||||
extension _AsyncThrottleSequence: Sendable where Base: Sendable, Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension _AsyncThrottleSequence.Iterator: Sendable { }
|
||||
extension _AsyncThrottleSequence.Iterator: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Returns an asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using the given error-throwing closure.
|
||||
@@ -23,13 +24,17 @@ extension AsyncSequence {
|
||||
/// the result. If the closure throws an error, the sequence throws.
|
||||
/// - Returns: An asynchronous sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func reductions<Result>(_ initial: Result, _ transform: @Sendable @escaping (Result, Element) async throws -> Result) -> AsyncThrowingExclusiveReductionsSequence<Self, Result> {
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @Sendable @escaping (Result, Element) async throws -> Result
|
||||
) -> AsyncThrowingExclusiveReductionsSequence<Self, Result> {
|
||||
reductions(into: initial) { result, element in
|
||||
result = try await transform(result, element)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Returns an asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using the given error-throwing closure.
|
||||
///
|
||||
@@ -44,81 +49,96 @@ extension AsyncSequence {
|
||||
/// error, the sequence throws.
|
||||
/// - Returns: An asynchronous sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func reductions<Result>(into initial: Result, _ transform: @Sendable @escaping (inout Result, Element) async throws -> Void) -> AsyncThrowingExclusiveReductionsSequence<Self, Result> {
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @Sendable @escaping (inout Result, Element) async throws -> Void
|
||||
) -> AsyncThrowingExclusiveReductionsSequence<Self, Result> {
|
||||
AsyncThrowingExclusiveReductionsSequence(self, initial: initial, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
/// An asynchronous sequence of applying an error-throwing transform to the element of
|
||||
/// an asynchronous sequence and the previously transformed result.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncThrowingExclusiveReductionsSequence<Base: AsyncSequence, Element> {
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let initial: Element
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let transform: @Sendable (inout Element, Base.Element) async throws -> Void
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ base: Base, initial: Element, transform: @Sendable @escaping (inout Element, Base.Element) async throws -> Void) {
|
||||
init(
|
||||
_ base: Base,
|
||||
initial: Element,
|
||||
transform: @Sendable @escaping (inout Element, Base.Element) async throws -> Void
|
||||
) {
|
||||
self.base = base
|
||||
self.initial = initial
|
||||
self.transform = transform
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingExclusiveReductionsSequence: AsyncSequence {
|
||||
/// The iterator for an `AsyncThrowingExclusiveReductionsSequence` instance.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
var iterator: Base.AsyncIterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
var current: Element?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let transform: @Sendable (inout Element, Base.Element) async throws -> Void
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ iterator: Base.AsyncIterator, initial: Element, transform: @Sendable @escaping (inout Element, Base.Element) async throws -> Void) {
|
||||
init(
|
||||
_ iterator: Base.AsyncIterator,
|
||||
initial: Element,
|
||||
transform: @Sendable @escaping (inout Element, Base.Element) async throws -> Void
|
||||
) {
|
||||
self.iterator = iterator
|
||||
self.current = initial
|
||||
self.transform = transform
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async throws -> Element? {
|
||||
guard let result = current else { return nil }
|
||||
guard var result = current else { return nil }
|
||||
let value = try await iterator.next()
|
||||
if let value = value {
|
||||
var result = result
|
||||
do {
|
||||
try await transform(&result, value)
|
||||
current = result
|
||||
return result
|
||||
} catch {
|
||||
current = nil
|
||||
throw error
|
||||
}
|
||||
} else {
|
||||
guard let value = value else {
|
||||
current = nil
|
||||
return nil
|
||||
}
|
||||
do {
|
||||
try await transform(&result, value)
|
||||
current = result
|
||||
return result
|
||||
} catch {
|
||||
current = nil
|
||||
throw error
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base.makeAsyncIterator(), initial: initial, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncThrowingExclusiveReductionsSequence: Sendable where Base: Sendable, Element: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingExclusiveReductionsSequence: Sendable where Base: Sendable, Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncThrowingExclusiveReductionsSequence.Iterator: Sendable { }
|
||||
extension AsyncThrowingExclusiveReductionsSequence.Iterator: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Returns an asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using the given error-throwing closure.
|
||||
@@ -27,6 +28,7 @@ extension AsyncSequence {
|
||||
/// result and the next element in the receiving sequence. If the closure
|
||||
/// throws an error, the sequence throws.
|
||||
/// - Returns: An asynchronous sequence of the reduced elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func reductions(
|
||||
_ transform: @Sendable @escaping (Element, Element) async throws -> Element
|
||||
@@ -37,14 +39,15 @@ extension AsyncSequence {
|
||||
|
||||
/// An asynchronous sequence containing the accumulated results of combining the
|
||||
/// elements of the asynchronous sequence using a given error-throwing closure.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct AsyncThrowingInclusiveReductionsSequence<Base: AsyncSequence> {
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
let transform: @Sendable (Base.Element, Base.Element) async throws -> Base.Element
|
||||
|
||||
|
||||
@inlinable
|
||||
init(_ base: Base, transform: @Sendable @escaping (Base.Element, Base.Element) async throws -> Base.Element) {
|
||||
self.base = base
|
||||
@@ -52,10 +55,12 @@ public struct AsyncThrowingInclusiveReductionsSequence<Base: AsyncSequence> {
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingInclusiveReductionsSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
|
||||
/// The iterator for an `AsyncThrowingInclusiveReductionsSequence` instance.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@frozen
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
@@ -93,13 +98,15 @@ extension AsyncThrowingInclusiveReductionsSequence: AsyncSequence {
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base.makeAsyncIterator(), transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncThrowingInclusiveReductionsSequence: Sendable where Base: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingInclusiveReductionsSequence: Sendable where Base: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncThrowingInclusiveReductionsSequence.Iterator: Sendable { }
|
||||
extension AsyncThrowingInclusiveReductionsSequence.Iterator: Sendable {}
|
||||
@@ -64,7 +64,11 @@ public struct AsyncTimerSequence<C: Clock>: AsyncSequence {
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncTimerSequence {
|
||||
/// Create an `AsyncTimerSequence` with a given repeating interval.
|
||||
public static func repeating(every interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncTimerSequence<C> {
|
||||
public static func repeating(
|
||||
every interval: C.Instant.Duration,
|
||||
tolerance: C.Instant.Duration? = nil,
|
||||
clock: C
|
||||
) -> AsyncTimerSequence<C> {
|
||||
return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: clock)
|
||||
}
|
||||
}
|
||||
@@ -72,13 +76,16 @@ extension AsyncTimerSequence {
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncTimerSequence where C == SuspendingClock {
|
||||
/// Create an `AsyncTimerSequence` with a given repeating interval.
|
||||
public static func repeating(every interval: Duration, tolerance: Duration? = nil) -> AsyncTimerSequence<SuspendingClock> {
|
||||
public static func repeating(
|
||||
every interval: Duration,
|
||||
tolerance: Duration? = nil
|
||||
) -> AsyncTimerSequence<SuspendingClock> {
|
||||
return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: SuspendingClock())
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncTimerSequence: Sendable { }
|
||||
extension AsyncTimerSequence: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncTimerSequence.Iterator: Sendable { }
|
||||
extension AsyncTimerSequence.Iterator: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence where Self: Sendable {
|
||||
/// Creates an asynchronous sequence that buffers elements.
|
||||
///
|
||||
@@ -20,6 +21,7 @@ extension AsyncSequence where Self: Sendable {
|
||||
///
|
||||
/// - Parameter policy: A policy that drives the behaviour of the ``AsyncBufferSequence``
|
||||
/// - Returns: An asynchronous sequence that buffers elements up to a given limit.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func buffer(
|
||||
policy: AsyncBufferSequencePolicy
|
||||
) -> AsyncBufferSequence<Self> {
|
||||
@@ -28,6 +30,7 @@ extension AsyncSequence where Self: Sendable {
|
||||
}
|
||||
|
||||
/// A policy dictating the buffering behaviour of an ``AsyncBufferSequence``
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncBufferSequencePolicy: Sendable {
|
||||
enum _Policy {
|
||||
case bounded(Int)
|
||||
@@ -69,6 +72,7 @@ public struct AsyncBufferSequencePolicy: Sendable {
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that buffers elements in regard to a policy.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence {
|
||||
enum StorageType {
|
||||
case transparent(Base.AsyncIterator)
|
||||
@@ -93,16 +97,16 @@ public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storageType: StorageType
|
||||
switch self.policy.policy {
|
||||
case .bounded(...0), .bufferingNewest(...0), .bufferingOldest(...0):
|
||||
storageType = .transparent(self.base.makeAsyncIterator())
|
||||
case .bounded(let limit):
|
||||
storageType = .bounded(storage: BoundedBufferStorage(base: self.base, limit: limit))
|
||||
case .unbounded:
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .unlimited))
|
||||
case .bufferingNewest(let limit):
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingNewest(limit)))
|
||||
case .bufferingOldest(let limit):
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingOldest(limit)))
|
||||
case .bounded(...0), .bufferingNewest(...0), .bufferingOldest(...0):
|
||||
storageType = .transparent(self.base.makeAsyncIterator())
|
||||
case .bounded(let limit):
|
||||
storageType = .bounded(storage: BoundedBufferStorage(base: self.base, limit: limit))
|
||||
case .unbounded:
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .unlimited))
|
||||
case .bufferingNewest(let limit):
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingNewest(limit)))
|
||||
case .bufferingOldest(let limit):
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingOldest(limit)))
|
||||
}
|
||||
return Iterator(storageType: storageType)
|
||||
}
|
||||
@@ -112,20 +116,21 @@ public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
switch self.storageType {
|
||||
case .transparent(var iterator):
|
||||
let element = try await iterator.next()
|
||||
self.storageType = .transparent(iterator)
|
||||
return element
|
||||
case .bounded(let storage):
|
||||
return try await storage.next()?._rethrowGet()
|
||||
case .unbounded(let storage):
|
||||
return try await storage.next()?._rethrowGet()
|
||||
case .transparent(var iterator):
|
||||
let element = try await iterator.next()
|
||||
self.storageType = .transparent(iterator)
|
||||
return element
|
||||
case .bounded(let storage):
|
||||
return try await storage.next()?._rethrowGet()
|
||||
case .unbounded(let storage):
|
||||
return try await storage.next()?._rethrowGet()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncBufferSequence: Sendable where Base: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncBufferSequence: Sendable where Base: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncBufferSequence.Iterator: Sendable { }
|
||||
extension AsyncBufferSequence.Iterator: Sendable {}
|
||||
@@ -11,6 +11,7 @@
|
||||
|
||||
import DequeModule
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
typealias Element = Base.Element
|
||||
typealias SuspendedProducer = UnsafeContinuation<Void, Never>
|
||||
@@ -41,52 +42,52 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
var task: Task<Void, Never>? {
|
||||
switch self.state {
|
||||
case .buffering(let task, _, _, _):
|
||||
return task
|
||||
default:
|
||||
return nil
|
||||
case .buffering(let task, _, _, _):
|
||||
return task
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
mutating func taskStarted(task: Task<Void, Never>) {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
self.state = .buffering(task: task, buffer: [], suspendedProducer: nil, suspendedConsumer: nil)
|
||||
|
||||
case .buffering:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .initial:
|
||||
self.state = .buffering(task: task, buffer: [], suspendedProducer: nil, suspendedConsumer: nil)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .buffering:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
preconditionFailure("Invalid state.")
|
||||
}
|
||||
}
|
||||
|
||||
mutating func shouldSuspendProducer() -> Bool {
|
||||
switch state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
|
||||
case .buffering(_, let buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if there are free slots, we should directly request the next element
|
||||
return buffer.count >= self.limit
|
||||
case .buffering(_, let buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if there are free slots, we should directly request the next element
|
||||
return buffer.count >= self.limit
|
||||
|
||||
case .buffering(_, _, .none, .some):
|
||||
// we have an awaiting consumer, we should not suspended the producer, we should
|
||||
// directly request the next element
|
||||
return false
|
||||
case .buffering(_, _, .none, .some):
|
||||
// we have an awaiting consumer, we should not suspended the producer, we should
|
||||
// directly request the next element
|
||||
return false
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There is already a suspended producer.")
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There is already a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return false
|
||||
case .finished:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
@@ -97,33 +98,40 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func producerSuspended(continuation: SuspendedProducer) -> ProducerSuspendedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
|
||||
case .buffering(let task, let buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if the buffer is available we resume the producer so it can we can request the next element
|
||||
// otherwise we confirm the suspension
|
||||
if buffer.count < limit {
|
||||
return .resumeProducer
|
||||
} else {
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: continuation, suspendedConsumer: nil)
|
||||
return .none
|
||||
}
|
||||
case .buffering(let task, let buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if the buffer is available we resume the producer so it can we can request the next element
|
||||
// otherwise we confirm the suspension
|
||||
guard buffer.count < limit else {
|
||||
self.state = .buffering(
|
||||
task: task,
|
||||
buffer: buffer,
|
||||
suspendedProducer: continuation,
|
||||
suspendedConsumer: nil
|
||||
)
|
||||
return .none
|
||||
}
|
||||
return .resumeProducer
|
||||
|
||||
case .buffering(_, let buffer, .none, .some):
|
||||
// we have an awaiting consumer, we can resume the producer so the next element can be requested
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty as we have an awaiting consumer already.")
|
||||
return .resumeProducer
|
||||
case .buffering(_, let buffer, .none, .some):
|
||||
// we have an awaiting consumer, we can resume the producer so the next element can be requested
|
||||
precondition(
|
||||
buffer.isEmpty,
|
||||
"Invalid state. The buffer should be empty as we have an awaiting consumer already."
|
||||
)
|
||||
return .resumeProducer
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There is already a suspended producer.")
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There is already a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .resumeProducer
|
||||
case .finished:
|
||||
return .resumeProducer
|
||||
}
|
||||
}
|
||||
|
||||
@@ -134,32 +142,35 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func elementProduced(element: Element) -> ElementProducedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
|
||||
case .buffering(let task, var buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// we have to stack the new element or suspend the producer if the buffer is full
|
||||
precondition(buffer.count < limit, "Invalid state. The buffer should be available for stacking a new element.")
|
||||
self.state = .modifying
|
||||
buffer.append(.success(.init(element)))
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .none
|
||||
case .buffering(let task, var buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// we have to stack the new element or suspend the producer if the buffer is full
|
||||
precondition(
|
||||
buffer.count < limit,
|
||||
"Invalid state. The buffer should be available for stacking a new element."
|
||||
)
|
||||
self.state = .modifying
|
||||
buffer.append(.success(.init(element)))
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, let buffer, .none, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it with the element and exit
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .resumeConsumer(continuation: suspendedConsumer, result: .success(element))
|
||||
case .buffering(let task, let buffer, .none, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it with the element and exit
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .resumeConsumer(continuation: suspendedConsumer, result: .success(element))
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There should not be a suspended producer.")
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There should not be a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
@@ -172,32 +183,32 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func finish(error: Error?) -> FinishAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
|
||||
case .buffering(_, var buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if we have an error we stack it in the buffer so it can be consumed later
|
||||
if let error {
|
||||
buffer.append(.failure(error))
|
||||
}
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .none
|
||||
case .buffering(_, var buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if we have an error we stack it in the buffer so it can be consumed later
|
||||
if let error {
|
||||
buffer.append(.failure(error))
|
||||
}
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .none
|
||||
|
||||
case .buffering(_, let buffer, .none, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(continuation: suspendedConsumer)
|
||||
case .buffering(_, let buffer, .none, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(continuation: suspendedConsumer)
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There should not be a suspended producer.")
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There should not be a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
@@ -209,34 +220,34 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func next() -> NextAction {
|
||||
switch state {
|
||||
case .initial(let base):
|
||||
return .startTask(base: base)
|
||||
case .initial(let base):
|
||||
return .startTask(base: base)
|
||||
|
||||
case .buffering(_, let buffer, .none, .none) where buffer.isEmpty:
|
||||
// we are idle, we must suspend the consumer
|
||||
return .suspend
|
||||
case .buffering(_, let buffer, .none, .none) where buffer.isEmpty:
|
||||
// we are idle, we must suspend the consumer
|
||||
return .suspend
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedProducer, .none):
|
||||
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .returnResult(producerContinuation: suspendedProducer, result: result.map { $0.wrapped })
|
||||
case .buffering(let task, var buffer, let suspendedProducer, .none):
|
||||
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .returnResult(producerContinuation: suspendedProducer, result: result.map { $0.wrapped })
|
||||
|
||||
case .buffering(_, _, _, .some):
|
||||
preconditionFailure("Invalid states. There is already a suspended consumer.")
|
||||
case .buffering(_, _, _, .some):
|
||||
preconditionFailure("Invalid states. There is already a suspended consumer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(producerContinuation: nil, result: nil)
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(producerContinuation: nil, result: nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(producerContinuation: nil, result: result.map { $0.wrapped })
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(producerContinuation: nil, result: result.map { $0.wrapped })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -247,35 +258,35 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func nextSuspended(continuation: SuspendedConsumer) -> NextSuspendedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already be started.")
|
||||
|
||||
case .buffering(let task, let buffer, .none, .none) where buffer.isEmpty:
|
||||
// we are idle, we confirm the suspension of the consumer
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: continuation)
|
||||
return .none
|
||||
case .buffering(let task, let buffer, .none, .none) where buffer.isEmpty:
|
||||
// we are idle, we confirm the suspension of the consumer
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: continuation)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedProducer, .none):
|
||||
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .returnResult(producerContinuation: suspendedProducer, result: result.map { $0.wrapped })
|
||||
case .buffering(let task, var buffer, let suspendedProducer, .none):
|
||||
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .returnResult(producerContinuation: suspendedProducer, result: result.map { $0.wrapped })
|
||||
|
||||
case .buffering(_, _, _, .some):
|
||||
preconditionFailure("Invalid states. There is already a suspended consumer.")
|
||||
case .buffering(_, _, _, .some):
|
||||
preconditionFailure("Invalid states. There is already a suspended consumer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(producerContinuation: nil, result: nil)
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(producerContinuation: nil, result: nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(producerContinuation: nil, result: result.map { $0.wrapped })
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(producerContinuation: nil, result: result.map { $0.wrapped })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -290,27 +301,29 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func interrupted() -> InterruptedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
case .initial:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
|
||||
case .buffering(let task, _, let suspendedProducer, let suspendedConsumer):
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeProducerAndConsumer(
|
||||
task: task,
|
||||
producerContinuation: suspendedProducer,
|
||||
consumerContinuation: suspendedConsumer
|
||||
)
|
||||
case .buffering(let task, _, let suspendedProducer, let suspendedConsumer):
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeProducerAndConsumer(
|
||||
task: task,
|
||||
producerContinuation: suspendedProducer,
|
||||
consumerContinuation: suspendedConsumer
|
||||
)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
case .finished:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension BoundedBufferStateMachine: Sendable where Base: Sendable { }
|
||||
extension BoundedBufferStateMachine.State: Sendable where Base: Sendable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension BoundedBufferStateMachine: Sendable where Base: Sendable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension BoundedBufferStateMachine.State: Sendable where Base: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Sendable {
|
||||
private let stateMachine: ManagedCriticalState<BoundedBufferStateMachine<Base>>
|
||||
|
||||
@@ -18,47 +19,49 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
|
||||
|
||||
func next() async -> Result<Base.Element, Error>? {
|
||||
return await withTaskCancellationHandler {
|
||||
let action: BoundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action: BoundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion {
|
||||
stateMachine in
|
||||
let action = stateMachine.next()
|
||||
switch action {
|
||||
case .startTask(let base):
|
||||
self.startTask(stateMachine: &stateMachine, base: base)
|
||||
return nil
|
||||
case .startTask(let base):
|
||||
self.startTask(stateMachine: &stateMachine, base: base)
|
||||
return nil
|
||||
|
||||
case .suspend:
|
||||
return action
|
||||
case .returnResult:
|
||||
return action
|
||||
case .suspend:
|
||||
return action
|
||||
case .returnResult:
|
||||
return action
|
||||
}
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
|
||||
case .suspend:
|
||||
break
|
||||
case .suspend:
|
||||
break
|
||||
|
||||
case .returnResult(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
return result
|
||||
case .returnResult(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
return result
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
|
||||
return await withUnsafeContinuation {
|
||||
(continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.nextSuspended(continuation: continuation)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .returnResult(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
continuation.resume(returning: result)
|
||||
case .none:
|
||||
break
|
||||
case .returnResult(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
@@ -86,10 +89,10 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer:
|
||||
continuation.resume()
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer:
|
||||
continuation.resume()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -103,10 +106,10 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
|
||||
stateMachine.elementProduced(element: element)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation, let result):
|
||||
continuation.resume(returning: result)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation, let result):
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -114,20 +117,20 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
|
||||
stateMachine.finish(error: nil)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
} catch {
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.finish(error: error)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: .failure(error))
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: .failure(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -140,12 +143,12 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
|
||||
stateMachine.interrupted()
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):
|
||||
task.cancel()
|
||||
producerContinuation?.resume()
|
||||
consumerContinuation?.resume(returning: nil)
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):
|
||||
task.cancel()
|
||||
producerContinuation?.resume()
|
||||
consumerContinuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
|
||||
import DequeModule
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
typealias Element = Base.Element
|
||||
typealias SuspendedConsumer = UnsafeContinuation<Result<Element, Error>?, Never>
|
||||
@@ -45,26 +46,26 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
var task: Task<Void, Never>? {
|
||||
switch self.state {
|
||||
case .buffering(let task, _, _):
|
||||
return task
|
||||
default:
|
||||
return nil
|
||||
case .buffering(let task, _, _):
|
||||
return task
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
mutating func taskStarted(task: Task<Void, Never>) {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
self.state = .buffering(task: task, buffer: [], suspendedConsumer: nil)
|
||||
case .initial:
|
||||
self.state = .buffering(task: task, buffer: [], suspendedConsumer: nil)
|
||||
|
||||
case .buffering:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .buffering:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .finished:
|
||||
preconditionFailure("Invalid state.")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -78,43 +79,43 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func elementProduced(element: Element) -> ElementProducedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, var buffer, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// we have to apply the policy when stacking the new element
|
||||
self.state = .modifying
|
||||
switch self.policy {
|
||||
case .unlimited:
|
||||
buffer.append(.success(.init(element)))
|
||||
case .bufferingNewest(let limit):
|
||||
if buffer.count >= limit {
|
||||
_ = buffer.popFirst()
|
||||
}
|
||||
buffer.append(.success(.init(element)))
|
||||
case .bufferingOldest(let limit):
|
||||
if buffer.count < limit {
|
||||
buffer.append(.success(.init(element)))
|
||||
}
|
||||
case .buffering(let task, var buffer, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// we have to apply the policy when stacking the new element
|
||||
self.state = .modifying
|
||||
switch self.policy {
|
||||
case .unlimited:
|
||||
buffer.append(.success(.init(element)))
|
||||
case .bufferingNewest(let limit):
|
||||
if buffer.count >= limit {
|
||||
_ = buffer.popFirst()
|
||||
}
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .none
|
||||
buffer.append(.success(.init(element)))
|
||||
case .bufferingOldest(let limit):
|
||||
if buffer.count < limit {
|
||||
buffer.append(.success(.init(element)))
|
||||
}
|
||||
}
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, let buffer, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it with the element
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .resumeConsumer(
|
||||
continuation: suspendedConsumer,
|
||||
result: .success(element)
|
||||
)
|
||||
case .buffering(let task, let buffer, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it with the element
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .resumeConsumer(
|
||||
continuation: suspendedConsumer,
|
||||
result: .success(element)
|
||||
)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
@@ -125,29 +126,29 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func finish(error: Error?) -> FinishAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(_, var buffer, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if we have an error we stack it in the buffer so it can be consumed later
|
||||
if let error {
|
||||
buffer.append(.failure(error))
|
||||
}
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .none
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(_, let buffer, let suspendedConsumer):
|
||||
// we have an awaiting consumer, we can resume it with nil or the error
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(continuation: suspendedConsumer)
|
||||
case .buffering(_, var buffer, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if we have an error we stack it in the buffer so it can be consumed later
|
||||
if let error {
|
||||
buffer.append(.failure(error))
|
||||
}
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .none
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .buffering(_, let buffer, let suspendedConsumer):
|
||||
// we have an awaiting consumer, we can resume it with nil or the error
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(continuation: suspendedConsumer)
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,33 +160,33 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func next() -> NextAction {
|
||||
switch self.state {
|
||||
case .initial(let base):
|
||||
return .startTask(base: base)
|
||||
|
||||
case .buffering(_, let buffer, let suspendedConsumer) where buffer.isEmpty:
|
||||
// we are idle, we have to suspend the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
return .suspend
|
||||
case .initial(let base):
|
||||
return .startTask(base: base)
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedConsumer):
|
||||
// the buffer is already in use, we can unstack a value and directly resume the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .returnResult(result.map { $0.wrapped })
|
||||
case .buffering(_, let buffer, let suspendedConsumer) where buffer.isEmpty:
|
||||
// we are idle, we have to suspend the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
return .suspend
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .buffering(let task, var buffer, let suspendedConsumer):
|
||||
// the buffer is already in use, we can unstack a value and directly resume the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .returnResult(result.map { $0.wrapped })
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(nil)
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(result.map { $0.wrapped })
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(result.map { $0.wrapped })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -196,34 +197,34 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func nextSuspended(continuation: SuspendedConsumer) -> NextSuspendedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, let buffer, let suspendedConsumer) where buffer.isEmpty:
|
||||
// we are idle, we confirm the suspension of the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: continuation)
|
||||
return .none
|
||||
case .buffering(let task, let buffer, let suspendedConsumer) where buffer.isEmpty:
|
||||
// we are idle, we confirm the suspension of the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: continuation)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedConsumer):
|
||||
// the buffer is already in use, we can unstack a value and directly resume the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .resumeConsumer(result.map { $0.wrapped })
|
||||
case .buffering(let task, var buffer, let suspendedConsumer):
|
||||
// the buffer is already in use, we can unstack a value and directly resume the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .resumeConsumer(result.map { $0.wrapped })
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .resumeConsumer(nil)
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .resumeConsumer(nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .resumeConsumer(result.map { $0.wrapped })
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .resumeConsumer(result.map { $0.wrapped })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -234,25 +235,25 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
|
||||
mutating func interrupted() -> InterruptedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
state = .finished(buffer: [])
|
||||
return .none
|
||||
|
||||
case .buffering(let task, _, let suspendedConsumer):
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(task: task, continuation: suspendedConsumer)
|
||||
case .initial:
|
||||
state = .finished(buffer: [])
|
||||
return .none
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
case .buffering(let task, _, let suspendedConsumer):
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(task: task, continuation: suspendedConsumer)
|
||||
|
||||
case .finished:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension UnboundedBufferStateMachine: Sendable where Base: Sendable { }
|
||||
extension UnboundedBufferStateMachine.State: Sendable where Base: Sendable { }
|
||||
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension UnboundedBufferStateMachine: Sendable where Base: Sendable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension UnboundedBufferStateMachine.State: Sendable where Base: Sendable {}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Sendable {
|
||||
private let stateMachine: ManagedCriticalState<UnboundedBufferStateMachine<Base>>
|
||||
|
||||
@@ -19,41 +20,43 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
|
||||
func next() async -> Result<Base.Element, Error>? {
|
||||
return await withTaskCancellationHandler {
|
||||
|
||||
let action: UnboundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action: UnboundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion {
|
||||
stateMachine in
|
||||
let action = stateMachine.next()
|
||||
switch action {
|
||||
case .startTask(let base):
|
||||
self.startTask(stateMachine: &stateMachine, base: base)
|
||||
return nil
|
||||
case .suspend:
|
||||
return action
|
||||
case .returnResult:
|
||||
return action
|
||||
case .startTask(let base):
|
||||
self.startTask(stateMachine: &stateMachine, base: base)
|
||||
return nil
|
||||
case .suspend:
|
||||
return action
|
||||
case .returnResult:
|
||||
return action
|
||||
}
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
case .suspend:
|
||||
break
|
||||
case .returnResult(let result):
|
||||
return result
|
||||
case .none:
|
||||
break
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
case .suspend:
|
||||
break
|
||||
case .returnResult(let result):
|
||||
return result
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
|
||||
return await withUnsafeContinuation {
|
||||
(continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.nextSuspended(continuation: continuation)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let result):
|
||||
continuation.resume(returning: result)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let result):
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
@@ -72,10 +75,10 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
|
||||
stateMachine.elementProduced(element: element)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation, let result):
|
||||
continuation.resume(returning: result)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation, let result):
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -83,20 +86,20 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
|
||||
stateMachine.finish(error: nil)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
} catch {
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.finish(error: error)
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: .failure(error))
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: .failure(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -109,11 +112,11 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
|
||||
stateMachine.interrupted()
|
||||
}
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let task, let continuation):
|
||||
task.cancel()
|
||||
continuation?.resume(returning: nil)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let task, let continuation):
|
||||
task.cancel()
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -19,6 +19,7 @@
|
||||
/// on the `Iterator` is made, or when `finish()` is called from another Task.
|
||||
/// As `finish()` induces a terminal state, there is no more need for a back pressure management.
|
||||
/// This function does not suspend and will finish all the pending iterations.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
|
||||
public typealias Element = Element
|
||||
public typealias AsyncIterator = Iterator
|
||||
@@ -60,4 +61,4 @@ public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncChannel.Iterator: Sendable { }
|
||||
extension AsyncChannel.Iterator: Sendable {}
|
||||
@@ -18,6 +18,7 @@
|
||||
/// and is resumed when the next call to `next()` on the `Iterator` is made, or when `finish()`/`fail(_:)` is called
|
||||
/// from another Task. As `finish()` and `fail(_:)` induce a terminal state, there is no more need for a back pressure management.
|
||||
/// Those functions do not suspend and will finish all the pending iterations.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: AsyncSequence, Sendable {
|
||||
public typealias Element = Element
|
||||
public typealias AsyncIterator = Iterator
|
||||
@@ -63,4 +64,4 @@ public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: Asyn
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncThrowingChannel.Iterator: Sendable { }
|
||||
extension AsyncThrowingChannel.Iterator: Sendable {}
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
import OrderedCollections
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
private struct SuspendedProducer: Hashable, Sendable {
|
||||
let id: UInt64
|
||||
@@ -61,7 +62,12 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
case terminated(Termination)
|
||||
}
|
||||
|
||||
private var state: State = .channeling(suspendedProducers: [], cancelledProducers: [], suspendedConsumers: [], cancelledConsumers: [])
|
||||
private var state: State = .channeling(
|
||||
suspendedProducers: [],
|
||||
cancelledProducers: [],
|
||||
suspendedConsumers: [],
|
||||
cancelledConsumers: []
|
||||
)
|
||||
|
||||
enum SendAction {
|
||||
case resumeConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
|
||||
@@ -70,23 +76,23 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
|
||||
mutating func send() -> SendAction {
|
||||
switch self.state {
|
||||
case .channeling(_, _, let suspendedConsumers, _) where suspendedConsumers.isEmpty:
|
||||
// we are idle or waiting for consumers, we have to suspend the producer
|
||||
return .suspend
|
||||
case .channeling(_, _, let suspendedConsumers, _) where suspendedConsumers.isEmpty:
|
||||
// we are idle or waiting for consumers, we have to suspend the producer
|
||||
return .suspend
|
||||
|
||||
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, let cancelledConsumers):
|
||||
// we are waiting for producers, we can resume the first available consumer
|
||||
let suspendedConsumer = suspendedConsumers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(continuation: suspendedConsumer.continuation)
|
||||
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, let cancelledConsumers):
|
||||
// we are waiting for producers, we can resume the first available consumer
|
||||
let suspendedConsumer = suspendedConsumers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(continuation: suspendedConsumer.continuation)
|
||||
|
||||
case .terminated:
|
||||
return .resumeConsumer(continuation: nil)
|
||||
case .terminated:
|
||||
return .resumeConsumer(continuation: nil)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,45 +107,44 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
producerID: UInt64
|
||||
) -> SendSuspendedAction? {
|
||||
switch self.state {
|
||||
case .channeling(var suspendedProducers, var cancelledProducers, var suspendedConsumers, let cancelledConsumers):
|
||||
let suspendedProducer = SuspendedProducer(id: producerID, continuation: continuation, element: element)
|
||||
if let _ = cancelledProducers.remove(suspendedProducer) {
|
||||
// the producer was already cancelled, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer
|
||||
}
|
||||
|
||||
if suspendedConsumers.isEmpty {
|
||||
// we are idle or waiting for consumers
|
||||
// we stack the incoming producer in a suspended state
|
||||
suspendedProducers.append(suspendedProducer)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
} else {
|
||||
// we are waiting for producers
|
||||
// we resume the first consumer
|
||||
let suspendedConsumer = suspendedConsumers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducerAndConsumer(continuation: suspendedConsumer.continuation)
|
||||
}
|
||||
|
||||
case .terminated:
|
||||
case .channeling(var suspendedProducers, var cancelledProducers, var suspendedConsumers, let cancelledConsumers):
|
||||
let suspendedProducer = SuspendedProducer(id: producerID, continuation: continuation, element: element)
|
||||
if let _ = cancelledProducers.remove(suspendedProducer) {
|
||||
// the producer was already cancelled, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer
|
||||
}
|
||||
|
||||
guard suspendedConsumers.isEmpty else {
|
||||
// we are waiting for producers
|
||||
// we resume the first consumer
|
||||
let suspendedConsumer = suspendedConsumers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducerAndConsumer(continuation: suspendedConsumer.continuation)
|
||||
}
|
||||
// we are idle or waiting for consumers
|
||||
// we stack the incoming producer in a suspended state
|
||||
suspendedProducers.append(suspendedProducer)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
|
||||
case .terminated:
|
||||
return .resumeProducer
|
||||
}
|
||||
}
|
||||
|
||||
@@ -150,33 +155,33 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
|
||||
mutating func sendCancelled(producerID: UInt64) -> SendCancelledAction {
|
||||
switch self.state {
|
||||
case .channeling(var suspendedProducers, var cancelledProducers, let suspendedConsumers, let cancelledConsumers):
|
||||
// the cancelled producer might be part of the waiting list
|
||||
let placeHolder = SuspendedProducer.placeHolder(id: producerID)
|
||||
case .channeling(var suspendedProducers, var cancelledProducers, let suspendedConsumers, let cancelledConsumers):
|
||||
// the cancelled producer might be part of the waiting list
|
||||
let placeHolder = SuspendedProducer.placeHolder(id: producerID)
|
||||
|
||||
if let removed = suspendedProducers.remove(placeHolder) {
|
||||
// the producer was cancelled after being added to the suspended ones, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer(continuation: removed.continuation)
|
||||
}
|
||||
|
||||
// the producer was cancelled before being added to the suspended ones
|
||||
cancelledProducers.update(with: placeHolder)
|
||||
if let removed = suspendedProducers.remove(placeHolder) {
|
||||
// the producer was cancelled after being added to the suspended ones, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
return .resumeProducer(continuation: removed.continuation)
|
||||
}
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
// the producer was cancelled before being added to the suspended ones
|
||||
cancelledProducers.update(with: placeHolder)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
@@ -190,24 +195,24 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
|
||||
mutating func finish(error: Failure?) -> FinishAction {
|
||||
switch self.state {
|
||||
case .channeling(let suspendedProducers, _, let suspendedConsumers, _):
|
||||
// no matter if we are idle, waiting for producers or waiting for consumers, we resume every thing that is suspended
|
||||
if let error {
|
||||
if suspendedConsumers.isEmpty {
|
||||
self.state = .terminated(.failed(error))
|
||||
} else {
|
||||
self.state = .terminated(.finished)
|
||||
}
|
||||
case .channeling(let suspendedProducers, _, let suspendedConsumers, _):
|
||||
// no matter if we are idle, waiting for producers or waiting for consumers, we resume every thing that is suspended
|
||||
if let error {
|
||||
if suspendedConsumers.isEmpty {
|
||||
self.state = .terminated(.failed(error))
|
||||
} else {
|
||||
self.state = .terminated(.finished)
|
||||
}
|
||||
return .resumeProducersAndConsumers(
|
||||
producerSontinuations: suspendedProducers.map { $0.continuation },
|
||||
consumerContinuations: suspendedConsumers.map { $0.continuation }
|
||||
)
|
||||
} else {
|
||||
self.state = .terminated(.finished)
|
||||
}
|
||||
return .resumeProducersAndConsumers(
|
||||
producerSontinuations: suspendedProducers.map { $0.continuation },
|
||||
consumerContinuations: suspendedConsumers.map { $0.continuation }
|
||||
)
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
case .terminated:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
@@ -218,30 +223,30 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
|
||||
mutating func next() -> NextAction {
|
||||
switch self.state {
|
||||
case .channeling(let suspendedProducers, _, _, _) where suspendedProducers.isEmpty:
|
||||
// we are idle or waiting for producers, we must suspend
|
||||
return .suspend
|
||||
case .channeling(let suspendedProducers, _, _, _) where suspendedProducers.isEmpty:
|
||||
// we are idle or waiting for producers, we must suspend
|
||||
return .suspend
|
||||
|
||||
case .channeling(var suspendedProducers, let cancelledProducers, let suspendedConsumers, let cancelledConsumers):
|
||||
// we are waiting for consumers, we can resume the first awaiting producer
|
||||
let suspendedProducer = suspendedProducers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer(
|
||||
continuation: suspendedProducer.continuation,
|
||||
result: .success(suspendedProducer.element)
|
||||
)
|
||||
case .channeling(var suspendedProducers, let cancelledProducers, let suspendedConsumers, let cancelledConsumers):
|
||||
// we are waiting for consumers, we can resume the first awaiting producer
|
||||
let suspendedProducer = suspendedProducers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer(
|
||||
continuation: suspendedProducer.continuation,
|
||||
result: .success(suspendedProducer.element)
|
||||
)
|
||||
|
||||
case .terminated(.failed(let error)):
|
||||
self.state = .terminated(.finished)
|
||||
return .resumeProducer(continuation: nil, result: .failure(error))
|
||||
case .terminated(.failed(let error)):
|
||||
self.state = .terminated(.finished)
|
||||
return .resumeProducer(continuation: nil, result: .failure(error))
|
||||
|
||||
case .terminated:
|
||||
return .resumeProducer(continuation: nil, result: .success(nil))
|
||||
case .terminated:
|
||||
return .resumeProducer(continuation: nil, result: .success(nil))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -256,52 +261,51 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
consumerID: UInt64
|
||||
) -> NextSuspendedAction? {
|
||||
switch self.state {
|
||||
case .channeling(var suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
|
||||
let suspendedConsumer = SuspendedConsumer(id: consumerID, continuation: continuation)
|
||||
if let _ = cancelledConsumers.remove(suspendedConsumer) {
|
||||
// the consumer was already cancelled, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(element: nil)
|
||||
}
|
||||
|
||||
if suspendedProducers.isEmpty {
|
||||
// we are idle or waiting for producers
|
||||
// we stack the incoming consumer in a suspended state
|
||||
suspendedConsumers.append(suspendedConsumer)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
} else {
|
||||
// we are waiting for consumers
|
||||
// we resume the first producer
|
||||
let suspendedProducer = suspendedProducers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducerAndConsumer(
|
||||
continuation: suspendedProducer.continuation,
|
||||
element: suspendedProducer.element
|
||||
)
|
||||
}
|
||||
|
||||
case .terminated(.finished):
|
||||
case .channeling(var suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
|
||||
let suspendedConsumer = SuspendedConsumer(id: consumerID, continuation: continuation)
|
||||
if let _ = cancelledConsumers.remove(suspendedConsumer) {
|
||||
// the consumer was already cancelled, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(element: nil)
|
||||
}
|
||||
|
||||
case .terminated(.failed(let error)):
|
||||
self.state = .terminated(.finished)
|
||||
return .resumeConsumerWithError(error: error)
|
||||
guard suspendedProducers.isEmpty else {
|
||||
// we are waiting for consumers
|
||||
// we resume the first producer
|
||||
let suspendedProducer = suspendedProducers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducerAndConsumer(
|
||||
continuation: suspendedProducer.continuation,
|
||||
element: suspendedProducer.element
|
||||
)
|
||||
}
|
||||
// we are idle or waiting for producers
|
||||
// we stack the incoming consumer in a suspended state
|
||||
suspendedConsumers.append(suspendedConsumer)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
|
||||
case .terminated(.finished):
|
||||
return .resumeConsumer(element: nil)
|
||||
|
||||
case .terminated(.failed(let error)):
|
||||
self.state = .terminated(.finished)
|
||||
return .resumeConsumerWithError(error: error)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -312,33 +316,33 @@ struct ChannelStateMachine<Element: Sendable, Failure: Error>: Sendable {
|
||||
|
||||
mutating func nextCancelled(consumerID: UInt64) -> NextCancelledAction {
|
||||
switch self.state {
|
||||
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
|
||||
// the cancelled consumer might be part of the suspended ones
|
||||
let placeHolder = SuspendedConsumer.placeHolder(id: consumerID)
|
||||
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
|
||||
// the cancelled consumer might be part of the suspended ones
|
||||
let placeHolder = SuspendedConsumer.placeHolder(id: consumerID)
|
||||
|
||||
if let removed = suspendedConsumers.remove(placeHolder) {
|
||||
// the consumer was cancelled after being added to the suspended ones, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(continuation: removed.continuation)
|
||||
}
|
||||
|
||||
// the consumer was cancelled before being added to the suspended ones
|
||||
cancelledConsumers.update(with: placeHolder)
|
||||
if let removed = suspendedConsumers.remove(placeHolder) {
|
||||
// the consumer was cancelled after being added to the suspended ones, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
return .resumeConsumer(continuation: removed.continuation)
|
||||
}
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
// the consumer was cancelled before being added to the suspended ones
|
||||
cancelledConsumers.update(with: placeHolder)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -8,6 +8,7 @@
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
private let stateMachine: ManagedCriticalState<ChannelStateMachine<Element, Failure>>
|
||||
private let ids = ManagedCriticalState<UInt64>(0)
|
||||
@@ -30,12 +31,12 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .suspend:
|
||||
case .suspend:
|
||||
break
|
||||
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: element)
|
||||
return
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: element)
|
||||
return
|
||||
}
|
||||
|
||||
let producerID = self.generateId()
|
||||
@@ -48,13 +49,13 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer:
|
||||
continuation.resume()
|
||||
case .resumeProducerAndConsumer(let consumerContinuation):
|
||||
continuation.resume()
|
||||
consumerContinuation?.resume(returning: element)
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer:
|
||||
continuation.resume()
|
||||
case .resumeProducerAndConsumer(let consumerContinuation):
|
||||
continuation.resume()
|
||||
consumerContinuation?.resume(returning: element)
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
@@ -63,10 +64,10 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer(let continuation):
|
||||
continuation?.resume()
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer(let continuation):
|
||||
continuation?.resume()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -77,15 +78,15 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducersAndConsumers(let producerContinuations, let consumerContinuations):
|
||||
producerContinuations.forEach { $0?.resume() }
|
||||
if let error {
|
||||
consumerContinuations.forEach { $0?.resume(throwing: error) }
|
||||
} else {
|
||||
consumerContinuations.forEach { $0?.resume(returning: nil) }
|
||||
}
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducersAndConsumers(let producerContinuations, let consumerContinuations):
|
||||
producerContinuations.forEach { $0?.resume() }
|
||||
if let error {
|
||||
consumerContinuations.forEach { $0?.resume(throwing: error) }
|
||||
} else {
|
||||
consumerContinuations.forEach { $0?.resume(returning: nil) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -95,12 +96,12 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .suspend:
|
||||
break
|
||||
case .suspend:
|
||||
break
|
||||
|
||||
case .resumeProducer(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
return try result._rethrowGet()
|
||||
case .resumeProducer(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
return try result._rethrowGet()
|
||||
}
|
||||
|
||||
let consumerID = self.generateId()
|
||||
@@ -115,15 +116,15 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let element):
|
||||
continuation.resume(returning: element)
|
||||
case .resumeConsumerWithError(let error):
|
||||
continuation.resume(throwing: error)
|
||||
case .resumeProducerAndConsumer(let producerContinuation, let element):
|
||||
producerContinuation?.resume()
|
||||
continuation.resume(returning: element)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let element):
|
||||
continuation.resume(returning: element)
|
||||
case .resumeConsumerWithError(let error):
|
||||
continuation.resume(throwing: error)
|
||||
case .resumeProducerAndConsumer(let producerContinuation, let element):
|
||||
producerContinuation?.resume()
|
||||
continuation.resume(returning: element)
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
@@ -132,10 +133,10 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,26 +20,32 @@
|
||||
/// Throws:
|
||||
/// ``combineLatest(_:_:)`` throws when one of the bases throws. If one of the bases threw any buffered and not yet consumed
|
||||
/// values will be dropped.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func combineLatest<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence
|
||||
>(_ base1: Base1, _ base2: Base2) -> AsyncCombineLatest2Sequence<Base1, Base2> where
|
||||
>(_ base1: Base1, _ base2: Base2) -> AsyncCombineLatest2Sequence<Base1, Base2>
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable {
|
||||
Base2.Element: Sendable
|
||||
{
|
||||
AsyncCombineLatest2Sequence(base1, base2)
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that combines the latest values produced from two asynchronous sequences into an asynchronous sequence of tuples.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncCombineLatest2Sequence<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence
|
||||
>: AsyncSequence, Sendable where
|
||||
>: AsyncSequence, Sendable
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable {
|
||||
Base2.Element: Sendable
|
||||
{
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
@@ -89,4 +95,4 @@ public struct AsyncCombineLatest2Sequence<
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncCombineLatest2Sequence.Iterator: Sendable { }
|
||||
extension AsyncCombineLatest2Sequence.Iterator: Sendable {}
|
||||
@@ -20,32 +20,38 @@
|
||||
/// Throws:
|
||||
/// ``combineLatest(_:_:_:)`` throws when one of the bases throws. If one of the bases threw any buffered and not yet consumed
|
||||
/// values will be dropped.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func combineLatest<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>(_ base1: Base1, _ base2: Base2, _ base3: Base3) -> AsyncCombineLatest3Sequence<Base1, Base2, Base3> where
|
||||
>(_ base1: Base1, _ base2: Base2, _ base3: Base3) -> AsyncCombineLatest3Sequence<Base1, Base2, Base3>
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3: Sendable,
|
||||
Base3.Element: Sendable {
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
AsyncCombineLatest3Sequence(base1, base2, base3)
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that combines the latest values produced from three asynchronous sequences into an asynchronous sequence of tuples.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncCombineLatest3Sequence<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: AsyncSequence, Sendable where
|
||||
>: AsyncSequence, Sendable
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3: Sendable,
|
||||
Base3.Element: Sendable {
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
public typealias Element = (Base1.Element, Base2.Element, Base3.Element)
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
@@ -60,7 +66,8 @@ public struct AsyncCombineLatest3Sequence<
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> AsyncIterator {
|
||||
Iterator(storage: .init(self.base1, self.base2, self.base3)
|
||||
Iterator(
|
||||
storage: .init(self.base1, self.base2, self.base3)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -99,4 +106,4 @@ public struct AsyncCombineLatest3Sequence<
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncCombineLatest3Sequence.Iterator: Sendable { }
|
||||
extension AsyncCombineLatest3Sequence.Iterator: Sendable {}
|
||||
@@ -12,22 +12,29 @@
|
||||
import DequeModule
|
||||
|
||||
/// State machine for combine latest
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct CombineLatestStateMachine<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: Sendable where
|
||||
>: Sendable
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base3: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3.Element: Sendable {
|
||||
typealias DownstreamContinuation = UnsafeContinuation<Result<(
|
||||
Base1.Element,
|
||||
Base2.Element,
|
||||
Base3.Element?
|
||||
)?, Error>, Never>
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
typealias DownstreamContinuation = UnsafeContinuation<
|
||||
Result<
|
||||
(
|
||||
Base1.Element,
|
||||
Base2.Element,
|
||||
Base3.Element?
|
||||
)?, Error
|
||||
>, Never
|
||||
>
|
||||
|
||||
private enum State: Sendable {
|
||||
/// Small wrapper for the state of an upstream sequence.
|
||||
@@ -115,7 +122,9 @@ struct CombineLatestStateMachine<
|
||||
|
||||
case .combining:
|
||||
// An iterator was deinitialized while we have a suspended continuation.
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received iteratorDeinitialized()")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received iteratorDeinitialized()"
|
||||
)
|
||||
|
||||
case .waitingForDemand(let task, let upstreams, _):
|
||||
// The iterator was dropped which signals that the consumer is finished.
|
||||
@@ -124,7 +133,8 @@ struct CombineLatestStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .upstreamThrew, .upstreamsFinished:
|
||||
@@ -180,7 +190,10 @@ struct CombineLatestStateMachine<
|
||||
)
|
||||
}
|
||||
|
||||
mutating func childTaskSuspended(baseIndex: Int, continuation: UnsafeContinuation<Void, Error>) -> ChildTaskSuspendedAction? {
|
||||
mutating func childTaskSuspended(
|
||||
baseIndex: Int,
|
||||
continuation: UnsafeContinuation<Void, Error>
|
||||
) -> ChildTaskSuspendedAction? {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
// Child tasks are only created after we transitioned to `zipping`
|
||||
@@ -203,7 +216,9 @@ struct CombineLatestStateMachine<
|
||||
upstreams.2.continuation = continuation
|
||||
|
||||
default:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received childTaskSuspended() with base index \(baseIndex)")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received childTaskSuspended() with base index \(baseIndex)"
|
||||
)
|
||||
}
|
||||
|
||||
self.state = .waitingForDemand(
|
||||
@@ -283,7 +298,10 @@ struct CombineLatestStateMachine<
|
||||
return .none
|
||||
|
||||
case .combining(let task, var upstreams, let downstreamContinuation, let buffer):
|
||||
precondition(buffer.isEmpty, "Internal inconsistency current state \(self.state) and the buffer is not empty")
|
||||
precondition(
|
||||
buffer.isEmpty,
|
||||
"Internal inconsistency current state \(self.state) and the buffer is not empty"
|
||||
)
|
||||
self.state = .modifying
|
||||
|
||||
switch result {
|
||||
@@ -302,8 +320,9 @@ struct CombineLatestStateMachine<
|
||||
|
||||
// Implementing this for the two arities without variadic generics is a bit awkward sadly.
|
||||
if let first = upstreams.0.element,
|
||||
let second = upstreams.1.element,
|
||||
let third = upstreams.2.element {
|
||||
let second = upstreams.1.element,
|
||||
let third = upstreams.2.element
|
||||
{
|
||||
// We got an element from each upstream so we can resume the downstream now
|
||||
self.state = .waitingForDemand(
|
||||
task: task,
|
||||
@@ -317,8 +336,9 @@ struct CombineLatestStateMachine<
|
||||
)
|
||||
|
||||
} else if let first = upstreams.0.element,
|
||||
let second = upstreams.1.element,
|
||||
self.numberOfUpstreamSequences == 2 {
|
||||
let second = upstreams.1.element,
|
||||
self.numberOfUpstreamSequences == 2
|
||||
{
|
||||
// We got an element from each upstream so we can resume the downstream now
|
||||
self.state = .waitingForDemand(
|
||||
task: task,
|
||||
@@ -335,9 +355,21 @@ struct CombineLatestStateMachine<
|
||||
self.state = .combining(
|
||||
task: task,
|
||||
upstreams: (
|
||||
.init(continuation: upstreams.0.continuation, element: upstreams.0.element, isFinished: upstreams.0.isFinished),
|
||||
.init(continuation: upstreams.1.continuation, element: upstreams.1.element, isFinished: upstreams.1.isFinished),
|
||||
.init(continuation: upstreams.2.continuation, element: upstreams.2.element, isFinished: upstreams.2.isFinished)
|
||||
.init(
|
||||
continuation: upstreams.0.continuation,
|
||||
element: upstreams.0.element,
|
||||
isFinished: upstreams.0.isFinished
|
||||
),
|
||||
.init(
|
||||
continuation: upstreams.1.continuation,
|
||||
element: upstreams.1.element,
|
||||
isFinished: upstreams.1.isFinished
|
||||
),
|
||||
.init(
|
||||
continuation: upstreams.2.continuation,
|
||||
element: upstreams.2.element,
|
||||
isFinished: upstreams.2.isFinished
|
||||
)
|
||||
),
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
buffer: buffer
|
||||
@@ -397,7 +429,9 @@ struct CombineLatestStateMachine<
|
||||
upstreams.2.isFinished = true
|
||||
|
||||
default:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received upstreamFinished() with base index \(baseIndex)")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received upstreamFinished() with base index \(baseIndex)"
|
||||
)
|
||||
}
|
||||
|
||||
if upstreams.0.isFinished && upstreams.1.isFinished && upstreams.2.isFinished {
|
||||
@@ -410,7 +444,9 @@ struct CombineLatestStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [
|
||||
upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation,
|
||||
].compactMap { $0 }
|
||||
)
|
||||
} else if upstreams.0.isFinished && upstreams.1.isFinished && self.numberOfUpstreamSequences == 2 {
|
||||
// All upstreams finished we can transition to either finished or upstreamsFinished now
|
||||
@@ -422,7 +458,9 @@ struct CombineLatestStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [
|
||||
upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation,
|
||||
].compactMap { $0 }
|
||||
)
|
||||
} else {
|
||||
self.state = .waitingForDemand(
|
||||
@@ -455,7 +493,9 @@ struct CombineLatestStateMachine<
|
||||
emptyUpstreamFinished = upstreams.2.element == nil
|
||||
|
||||
default:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received upstreamFinished() with base index \(baseIndex)")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received upstreamFinished() with base index \(baseIndex)"
|
||||
)
|
||||
}
|
||||
|
||||
// Implementing this for the two arities without variadic generics is a bit awkward sadly.
|
||||
@@ -466,7 +506,9 @@ struct CombineLatestStateMachine<
|
||||
return .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [
|
||||
upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation,
|
||||
].compactMap { $0 }
|
||||
)
|
||||
|
||||
} else if upstreams.0.isFinished && upstreams.1.isFinished && upstreams.2.isFinished {
|
||||
@@ -476,7 +518,9 @@ struct CombineLatestStateMachine<
|
||||
return .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [
|
||||
upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation,
|
||||
].compactMap { $0 }
|
||||
)
|
||||
|
||||
} else if upstreams.0.isFinished && upstreams.1.isFinished && self.numberOfUpstreamSequences == 2 {
|
||||
@@ -486,7 +530,9 @@ struct CombineLatestStateMachine<
|
||||
return .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [
|
||||
upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation,
|
||||
].compactMap { $0 }
|
||||
)
|
||||
} else {
|
||||
self.state = .combining(
|
||||
@@ -542,7 +588,8 @@ struct CombineLatestStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .combining(let task, let upstreams, let downstreamContinuation, _):
|
||||
@@ -555,7 +602,8 @@ struct CombineLatestStateMachine<
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
error: error,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .upstreamThrew, .finished:
|
||||
@@ -597,7 +645,8 @@ struct CombineLatestStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .combining(let task, let upstreams, let downstreamContinuation, _):
|
||||
@@ -608,7 +657,8 @@ struct CombineLatestStateMachine<
|
||||
return .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .upstreamsFinished:
|
||||
@@ -661,19 +711,10 @@ struct CombineLatestStateMachine<
|
||||
// If not we have to transition to combining and need to resume all upstream continuations now
|
||||
self.state = .modifying
|
||||
|
||||
if let element = buffer.popFirst() {
|
||||
self.state = .waitingForDemand(
|
||||
task: task,
|
||||
upstreams: upstreams,
|
||||
buffer: buffer
|
||||
)
|
||||
|
||||
return .resumeContinuation(
|
||||
downstreamContinuation: continuation,
|
||||
result: .success(element)
|
||||
)
|
||||
} else {
|
||||
let upstreamContinuations = [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
guard let element = buffer.popFirst() else {
|
||||
let upstreamContinuations = [
|
||||
upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation,
|
||||
].compactMap { $0 }
|
||||
upstreams.0.continuation = nil
|
||||
upstreams.1.continuation = nil
|
||||
upstreams.2.continuation = nil
|
||||
@@ -689,22 +730,31 @@ struct CombineLatestStateMachine<
|
||||
upstreamContinuation: upstreamContinuations
|
||||
)
|
||||
}
|
||||
self.state = .waitingForDemand(
|
||||
task: task,
|
||||
upstreams: upstreams,
|
||||
buffer: buffer
|
||||
)
|
||||
|
||||
return .resumeContinuation(
|
||||
downstreamContinuation: continuation,
|
||||
result: .success(element)
|
||||
)
|
||||
|
||||
case .upstreamsFinished(var buffer):
|
||||
self.state = .modifying
|
||||
|
||||
if let element = buffer.popFirst() {
|
||||
self.state = .upstreamsFinished(buffer: buffer)
|
||||
|
||||
return .resumeContinuation(
|
||||
downstreamContinuation: continuation,
|
||||
result: .success(element)
|
||||
)
|
||||
} else {
|
||||
guard let element = buffer.popFirst() else {
|
||||
self.state = .finished
|
||||
|
||||
return .resumeDownstreamContinuationWithNil(continuation)
|
||||
}
|
||||
self.state = .upstreamsFinished(buffer: buffer)
|
||||
|
||||
return .resumeContinuation(
|
||||
downstreamContinuation: continuation,
|
||||
result: .success(element)
|
||||
)
|
||||
|
||||
case .upstreamThrew(let error):
|
||||
// One of the upstreams threw and we have to return this error now.
|
||||
|
||||
@@ -9,17 +9,20 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
final class CombineLatestStorage<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: Sendable where
|
||||
>: Sendable
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3: Sendable,
|
||||
Base3.Element: Sendable {
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
typealias StateMachine = CombineLatestStateMachine<Base1, Base2, Base3>
|
||||
|
||||
private let stateMachine: ManagedCriticalState<StateMachine>
|
||||
@@ -340,33 +343,33 @@ final class CombineLatestStorage<
|
||||
}
|
||||
|
||||
while !group.isEmpty {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.upstreamThrew(error)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
|
||||
let downstreamContinuation,
|
||||
let error,
|
||||
let task,
|
||||
let upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
downstreamContinuation.resume(returning: .failure(error))
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
group.cancelAll()
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.upstreamThrew(error)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
|
||||
let downstreamContinuation,
|
||||
let error,
|
||||
let task,
|
||||
let upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
downstreamContinuation.resume(returning: .failure(error))
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
group.cancelAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,94 +9,102 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Creates an asynchronous sequence that emits the latest element after a given quiescence period
|
||||
/// has elapsed by using a specified Clock.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func debounce<C: Clock>(for interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncDebounceSequence<Self, C> where Self: Sendable, Self.Element: Sendable {
|
||||
AsyncDebounceSequence(self, interval: interval, tolerance: tolerance, clock: clock)
|
||||
}
|
||||
/// Creates an asynchronous sequence that emits the latest element after a given quiescence period
|
||||
/// has elapsed by using a specified Clock.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func debounce<C: Clock>(
|
||||
for interval: C.Instant.Duration,
|
||||
tolerance: C.Instant.Duration? = nil,
|
||||
clock: C
|
||||
) -> AsyncDebounceSequence<Self, C> where Self: Sendable, Self.Element: Sendable {
|
||||
AsyncDebounceSequence(self, interval: interval, tolerance: tolerance, clock: clock)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that emits the latest element after a given quiescence period
|
||||
/// has elapsed.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func debounce(for interval: Duration, tolerance: Duration? = nil) -> AsyncDebounceSequence<Self, ContinuousClock> where Self: Sendable, Self.Element: Sendable {
|
||||
self.debounce(for: interval, tolerance: tolerance, clock: .continuous)
|
||||
}
|
||||
/// Creates an asynchronous sequence that emits the latest element after a given quiescence period
|
||||
/// has elapsed.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public func debounce(
|
||||
for interval: Duration,
|
||||
tolerance: Duration? = nil
|
||||
) -> AsyncDebounceSequence<Self, ContinuousClock> where Self: Sendable, Self.Element: Sendable {
|
||||
self.debounce(for: interval, tolerance: tolerance, clock: .continuous)
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that emits the latest element after a given quiescence period
|
||||
/// has elapsed.
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public struct AsyncDebounceSequence<Base: AsyncSequence & Sendable, C: Clock>: Sendable where Base.Element: Sendable {
|
||||
private let base: Base
|
||||
private let clock: C
|
||||
private let interval: C.Instant.Duration
|
||||
private let tolerance: C.Instant.Duration?
|
||||
private let base: Base
|
||||
private let clock: C
|
||||
private let interval: C.Instant.Duration
|
||||
private let tolerance: C.Instant.Duration?
|
||||
|
||||
/// Initializes a new ``AsyncDebounceSequence``.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - base: The base sequence.
|
||||
/// - interval: The interval to debounce.
|
||||
/// - tolerance: The tolerance of the clock.
|
||||
/// - clock: The clock.
|
||||
init(_ base: Base, interval: C.Instant.Duration, tolerance: C.Instant.Duration?, clock: C) {
|
||||
self.base = base
|
||||
self.interval = interval
|
||||
self.tolerance = tolerance
|
||||
self.clock = clock
|
||||
}
|
||||
/// Initializes a new ``AsyncDebounceSequence``.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - base: The base sequence.
|
||||
/// - interval: The interval to debounce.
|
||||
/// - tolerance: The tolerance of the clock.
|
||||
/// - clock: The clock.
|
||||
init(_ base: Base, interval: C.Instant.Duration, tolerance: C.Instant.Duration?, clock: C) {
|
||||
self.base = base
|
||||
self.interval = interval
|
||||
self.tolerance = tolerance
|
||||
self.clock = clock
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncDebounceSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
public typealias Element = Base.Element
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storage = DebounceStorage(
|
||||
base: self.base,
|
||||
interval: self.interval,
|
||||
tolerance: self.tolerance,
|
||||
clock: self.clock
|
||||
)
|
||||
return Iterator(storage: storage)
|
||||
}
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storage = DebounceStorage(
|
||||
base: self.base,
|
||||
interval: self.interval,
|
||||
tolerance: self.tolerance,
|
||||
clock: self.clock
|
||||
)
|
||||
return Iterator(storage: storage)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncDebounceSequence {
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
/// This class is needed to hook the deinit to observe once all references to the ``AsyncIterator`` are dropped.
|
||||
///
|
||||
/// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncIterator`` struct itself.
|
||||
final class InternalClass: Sendable {
|
||||
private let storage: DebounceStorage<Base, C>
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
/// This class is needed to hook the deinit to observe once all references to the ``AsyncIterator`` are dropped.
|
||||
///
|
||||
/// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncIterator`` struct itself.
|
||||
final class InternalClass: Sendable {
|
||||
private let storage: DebounceStorage<Base, C>
|
||||
|
||||
fileprivate init(storage: DebounceStorage<Base, C>) {
|
||||
self.storage = storage
|
||||
}
|
||||
fileprivate init(storage: DebounceStorage<Base, C>) {
|
||||
self.storage = storage
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.storage.iteratorDeinitialized()
|
||||
}
|
||||
deinit {
|
||||
self.storage.iteratorDeinitialized()
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
try await self.storage.next()
|
||||
}
|
||||
}
|
||||
|
||||
let internalClass: InternalClass
|
||||
|
||||
fileprivate init(storage: DebounceStorage<Base, C>) {
|
||||
self.internalClass = InternalClass(storage: storage)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
try await self.internalClass.next()
|
||||
}
|
||||
func next() async rethrows -> Element? {
|
||||
try await self.storage.next()
|
||||
}
|
||||
}
|
||||
|
||||
let internalClass: InternalClass
|
||||
|
||||
fileprivate init(storage: DebounceStorage<Base, C>) {
|
||||
self.internalClass = InternalClass(storage: storage)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
try await self.internalClass.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncDebounceSequence.Iterator: Sendable { }
|
||||
extension AsyncDebounceSequence.Iterator: Sendable {}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -11,312 +11,317 @@
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
final class DebounceStorage<Base: AsyncSequence & Sendable, C: Clock>: Sendable where Base.Element: Sendable {
|
||||
typealias Element = Base.Element
|
||||
typealias Element = Base.Element
|
||||
|
||||
/// The state machine protected with a lock.
|
||||
private let stateMachine: ManagedCriticalState<DebounceStateMachine<Base, C>>
|
||||
/// The interval to debounce.
|
||||
private let interval: C.Instant.Duration
|
||||
/// The tolerance for the clock.
|
||||
private let tolerance: C.Instant.Duration?
|
||||
/// The clock.
|
||||
private let clock: C
|
||||
/// The state machine protected with a lock.
|
||||
private let stateMachine: ManagedCriticalState<DebounceStateMachine<Base, C>>
|
||||
/// The interval to debounce.
|
||||
private let interval: C.Instant.Duration
|
||||
/// The tolerance for the clock.
|
||||
private let tolerance: C.Instant.Duration?
|
||||
/// The clock.
|
||||
private let clock: C
|
||||
|
||||
init(base: Base, interval: C.Instant.Duration, tolerance: C.Instant.Duration?, clock: C) {
|
||||
self.stateMachine = .init(.init(base: base, clock: clock, interval: interval))
|
||||
self.interval = interval
|
||||
self.tolerance = tolerance
|
||||
self.clock = clock
|
||||
init(base: Base, interval: C.Instant.Duration, tolerance: C.Instant.Duration?, clock: C) {
|
||||
self.stateMachine = .init(.init(base: base, clock: clock, interval: interval))
|
||||
self.interval = interval
|
||||
self.tolerance = tolerance
|
||||
self.clock = clock
|
||||
}
|
||||
|
||||
func iteratorDeinitialized() {
|
||||
let action = self.stateMachine.withCriticalRegion { $0.iteratorDeinitialized() }
|
||||
|
||||
switch action {
|
||||
case .cancelTaskAndUpstreamAndClockContinuations(
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
task.cancel()
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
func iteratorDeinitialized() {
|
||||
let action = self.stateMachine.withCriticalRegion { $0.iteratorDeinitialized() }
|
||||
func next() async rethrows -> Element? {
|
||||
// We need to handle cancellation here because we are creating a continuation
|
||||
// and because we need to cancel the `Task` we created to consume the upstream
|
||||
return try await withTaskCancellationHandler {
|
||||
// We always suspend since we can never return an element right away
|
||||
|
||||
let result: Result<Element?, Error> = await withUnsafeContinuation { continuation in
|
||||
let action: DebounceStateMachine<Base, C>.NextAction? = self.stateMachine.withCriticalRegion {
|
||||
let action = $0.next(for: continuation)
|
||||
|
||||
switch action {
|
||||
case .startTask(let base):
|
||||
self.startTask(
|
||||
stateMachine: &$0,
|
||||
base: base,
|
||||
downstreamContinuation: continuation
|
||||
)
|
||||
return nil
|
||||
|
||||
case .resumeUpstreamContinuation:
|
||||
return action
|
||||
|
||||
case .resumeUpstreamAndClockContinuation:
|
||||
return action
|
||||
|
||||
case .resumeDownstreamContinuationWithNil:
|
||||
return action
|
||||
|
||||
case .resumeDownstreamContinuationWithError:
|
||||
return action
|
||||
}
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .cancelTaskAndUpstreamAndClockContinuations(
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
|
||||
task.cancel()
|
||||
case .resumeUpstreamContinuation(let upstreamContinuation):
|
||||
// This is signalling the upstream task that is consuming the upstream
|
||||
// sequence to signal demand.
|
||||
upstreamContinuation?.resume(returning: ())
|
||||
|
||||
case .resumeUpstreamAndClockContinuation(let upstreamContinuation, let clockContinuation, let deadline):
|
||||
// This is signalling the upstream task that is consuming the upstream
|
||||
// sequence to signal demand and start the clock task.
|
||||
upstreamContinuation?.resume(returning: ())
|
||||
clockContinuation?.resume(returning: deadline)
|
||||
|
||||
case .resumeDownstreamContinuationWithNil(let continuation):
|
||||
continuation.resume(returning: .success(nil))
|
||||
|
||||
case .resumeDownstreamContinuationWithError(let continuation, let error):
|
||||
continuation.resume(returning: .failure(error))
|
||||
|
||||
case .none:
|
||||
break
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return try result._rethrowGet()
|
||||
} onCancel: {
|
||||
let action = self.stateMachine.withCriticalRegion { $0.cancelled() }
|
||||
|
||||
switch action {
|
||||
case .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamAndClockContinuation(
|
||||
let downstreamContinuation,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .success(nil))
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
// We need to handle cancellation here because we are creating a continuation
|
||||
// and because we need to cancel the `Task` we created to consume the upstream
|
||||
return try await withTaskCancellationHandler {
|
||||
// We always suspend since we can never return an element right away
|
||||
private func startTask(
|
||||
stateMachine: inout DebounceStateMachine<Base, C>,
|
||||
base: Base,
|
||||
downstreamContinuation: UnsafeContinuation<Result<Base.Element?, Error>, Never>
|
||||
) {
|
||||
let task = Task {
|
||||
await withThrowingTaskGroup(of: Void.self) { group in
|
||||
// The task that consumes the upstream sequence
|
||||
group.addTask {
|
||||
var iterator = base.makeAsyncIterator()
|
||||
|
||||
let result: Result<Element?, Error> = await withUnsafeContinuation { continuation in
|
||||
let action: DebounceStateMachine<Base, C>.NextAction? = self.stateMachine.withCriticalRegion {
|
||||
let action = $0.next(for: continuation)
|
||||
|
||||
switch action {
|
||||
case .startTask(let base):
|
||||
self.startTask(
|
||||
stateMachine: &$0,
|
||||
base: base,
|
||||
downstreamContinuation: continuation
|
||||
)
|
||||
return nil
|
||||
|
||||
case .resumeUpstreamContinuation:
|
||||
return action
|
||||
|
||||
case .resumeUpstreamAndClockContinuation:
|
||||
return action
|
||||
|
||||
case .resumeDownstreamContinuationWithNil:
|
||||
return action
|
||||
|
||||
case .resumeDownstreamContinuationWithError:
|
||||
return action
|
||||
}
|
||||
}
|
||||
// This is our upstream consumption loop
|
||||
loop: while true {
|
||||
// We are creating a continuation before requesting the next
|
||||
// element from upstream. This continuation is only resumed
|
||||
// if the downstream consumer called `next` to signal his demand
|
||||
// and until the Clock sleep finished.
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.withCriticalRegion { $0.upstreamTaskSuspended(continuation) }
|
||||
|
||||
switch action {
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
case .resumeContinuation(let continuation):
|
||||
// This happens if there is outstanding demand
|
||||
// and we need to demand from upstream right away
|
||||
continuation.resume(returning: ())
|
||||
|
||||
case .resumeUpstreamContinuation(let upstreamContinuation):
|
||||
// This is signalling the upstream task that is consuming the upstream
|
||||
// sequence to signal demand.
|
||||
upstreamContinuation?.resume(returning: ())
|
||||
|
||||
case .resumeUpstreamAndClockContinuation(let upstreamContinuation, let clockContinuation, let deadline):
|
||||
// This is signalling the upstream task that is consuming the upstream
|
||||
// sequence to signal demand and start the clock task.
|
||||
upstreamContinuation?.resume(returning: ())
|
||||
clockContinuation?.resume(returning: deadline)
|
||||
|
||||
case .resumeDownstreamContinuationWithNil(let continuation):
|
||||
continuation.resume(returning: .success(nil))
|
||||
|
||||
case .resumeDownstreamContinuationWithError(let continuation, let error):
|
||||
continuation.resume(returning: .failure(error))
|
||||
case .resumeContinuationWithError(let continuation, let error):
|
||||
// This happens if the task got cancelled.
|
||||
continuation.resume(throwing: error)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return try result._rethrowGet()
|
||||
} onCancel: {
|
||||
let action = self.stateMachine.withCriticalRegion { $0.cancelled() }
|
||||
// We got signalled from the downstream that we have demand so let's
|
||||
// request a new element from the upstream
|
||||
if let element = try await iterator.next() {
|
||||
let action = self.stateMachine.withCriticalRegion {
|
||||
let deadline = self.clock.now.advanced(by: self.interval)
|
||||
return $0.elementProduced(element, deadline: deadline)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamAndClockContinuation(
|
||||
switch action {
|
||||
case .resumeClockContinuation(let clockContinuation, let deadline):
|
||||
clockContinuation?.resume(returning: deadline)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
} else {
|
||||
// The upstream returned `nil` which indicates that it finished
|
||||
let action = self.stateMachine.withCriticalRegion { $0.upstreamFinished() }
|
||||
|
||||
// All of this is mostly cleanup around the Task and the outstanding
|
||||
// continuations used for signalling.
|
||||
switch action {
|
||||
case .cancelTaskAndClockContinuation(let task, let clockContinuation):
|
||||
task.cancel()
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
break loop
|
||||
case .resumeContinuationWithNilAndCancelTaskAndUpstreamAndClockContinuation(
|
||||
let downstreamContinuation,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .success(nil))
|
||||
|
||||
case .none:
|
||||
break loop
|
||||
|
||||
case .resumeContinuationWithElementAndCancelTaskAndUpstreamAndClockContinuation(
|
||||
let downstreamContinuation,
|
||||
let element,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .success(element))
|
||||
|
||||
break loop
|
||||
|
||||
case .none:
|
||||
|
||||
break loop
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
group.addTask {
|
||||
// This is our clock scheduling loop
|
||||
loop: while true {
|
||||
do {
|
||||
// We are creating a continuation sleeping on the Clock.
|
||||
// This continuation is only resumed if the downstream consumer called `next`.
|
||||
let deadline: C.Instant = try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.withCriticalRegion {
|
||||
$0.clockTaskSuspended(continuation)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .resumeContinuation(let continuation, let deadline):
|
||||
// This happens if there is outstanding demand
|
||||
// and we need to demand from upstream right away
|
||||
continuation.resume(returning: deadline)
|
||||
|
||||
case .resumeContinuationWithError(let continuation, let error):
|
||||
// This happens if the task got cancelled.
|
||||
continuation.resume(throwing: error)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
try await self.clock.sleep(until: deadline, tolerance: self.tolerance)
|
||||
|
||||
let action = self.stateMachine.withCriticalRegion { $0.clockSleepFinished() }
|
||||
|
||||
switch action {
|
||||
case .resumeDownstreamContinuation(let downstreamContinuation, let element):
|
||||
downstreamContinuation.resume(returning: .success(element))
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
} catch {
|
||||
// The only error that we expect is the `CancellationError`
|
||||
// thrown from the Clock.sleep or from the withUnsafeContinuation.
|
||||
// This happens if we are cleaning everything up. We can just drop that error and break our loop
|
||||
precondition(
|
||||
error is CancellationError,
|
||||
"Received unexpected error \(error) in the Clock loop"
|
||||
)
|
||||
break loop
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func startTask(
|
||||
stateMachine: inout DebounceStateMachine<Base, C>,
|
||||
base: Base,
|
||||
downstreamContinuation: UnsafeContinuation<Result<Base.Element?, Error>, Never>
|
||||
) {
|
||||
let task = Task {
|
||||
await withThrowingTaskGroup(of: Void.self) { group in
|
||||
// The task that consumes the upstream sequence
|
||||
group.addTask {
|
||||
var iterator = base.makeAsyncIterator()
|
||||
|
||||
// This is our upstream consumption loop
|
||||
loop: while true {
|
||||
// We are creating a continuation before requesting the next
|
||||
// element from upstream. This continuation is only resumed
|
||||
// if the downstream consumer called `next` to signal his demand
|
||||
// and until the Clock sleep finished.
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.withCriticalRegion { $0.upstreamTaskSuspended(continuation) }
|
||||
|
||||
switch action {
|
||||
case .resumeContinuation(let continuation):
|
||||
// This happens if there is outstanding demand
|
||||
// and we need to demand from upstream right away
|
||||
continuation.resume(returning: ())
|
||||
|
||||
case .resumeContinuationWithError(let continuation, let error):
|
||||
// This happens if the task got cancelled.
|
||||
continuation.resume(throwing: error)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// We got signalled from the downstream that we have demand so let's
|
||||
// request a new element from the upstream
|
||||
if let element = try await iterator.next() {
|
||||
let action = self.stateMachine.withCriticalRegion {
|
||||
let deadline = self.clock.now.advanced(by: self.interval)
|
||||
return $0.elementProduced(element, deadline: deadline)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .resumeClockContinuation(let clockContinuation, let deadline):
|
||||
clockContinuation?.resume(returning: deadline)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
} else {
|
||||
// The upstream returned `nil` which indicates that it finished
|
||||
let action = self.stateMachine.withCriticalRegion { $0.upstreamFinished() }
|
||||
|
||||
// All of this is mostly cleanup around the Task and the outstanding
|
||||
// continuations used for signalling.
|
||||
switch action {
|
||||
case .cancelTaskAndClockContinuation(let task, let clockContinuation):
|
||||
task.cancel()
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
break loop
|
||||
case .resumeContinuationWithNilAndCancelTaskAndUpstreamAndClockContinuation(
|
||||
let downstreamContinuation,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .success(nil))
|
||||
|
||||
break loop
|
||||
|
||||
case .resumeContinuationWithElementAndCancelTaskAndUpstreamAndClockContinuation(
|
||||
let downstreamContinuation,
|
||||
let element,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .success(element))
|
||||
|
||||
break loop
|
||||
|
||||
case .none:
|
||||
|
||||
break loop
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
group.addTask {
|
||||
// This is our clock scheduling loop
|
||||
loop: while true {
|
||||
do {
|
||||
// We are creating a continuation sleeping on the Clock.
|
||||
// This continuation is only resumed if the downstream consumer called `next`.
|
||||
let deadline: C.Instant = try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.withCriticalRegion { $0.clockTaskSuspended(continuation) }
|
||||
|
||||
switch action {
|
||||
case .resumeContinuation(let continuation, let deadline):
|
||||
// This happens if there is outstanding demand
|
||||
// and we need to demand from upstream right away
|
||||
continuation.resume(returning: deadline)
|
||||
|
||||
case .resumeContinuationWithError(let continuation, let error):
|
||||
// This happens if the task got cancelled.
|
||||
continuation.resume(throwing: error)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
try await self.clock.sleep(until: deadline, tolerance: self.tolerance)
|
||||
|
||||
let action = self.stateMachine.withCriticalRegion { $0.clockSleepFinished() }
|
||||
|
||||
switch action {
|
||||
case .resumeDownstreamContinuation(let downstreamContinuation, let element):
|
||||
downstreamContinuation.resume(returning: .success(element))
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
} catch {
|
||||
// The only error that we expect is the `CancellationError`
|
||||
// thrown from the Clock.sleep or from the withUnsafeContinuation.
|
||||
// This happens if we are cleaning everything up. We can just drop that error and break our loop
|
||||
precondition(error is CancellationError, "Received unexpected error \(error) in the Clock loop")
|
||||
break loop
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while !group.isEmpty {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.upstreamThrew(error)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuation(
|
||||
let downstreamContinuation,
|
||||
let error,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .failure(error))
|
||||
|
||||
case .cancelTaskAndClockContinuation(
|
||||
let task,
|
||||
let clockContinuation
|
||||
):
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
task.cancel()
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
group.cancelAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stateMachine.taskStarted(task, downstreamContinuation: downstreamContinuation)
|
||||
while !group.isEmpty {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.upstreamThrew(error)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuation(
|
||||
let downstreamContinuation,
|
||||
let error,
|
||||
let task,
|
||||
let upstreamContinuation,
|
||||
let clockContinuation
|
||||
):
|
||||
upstreamContinuation?.resume(throwing: CancellationError())
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .failure(error))
|
||||
|
||||
case .cancelTaskAndClockContinuation(
|
||||
let task,
|
||||
let clockContinuation
|
||||
):
|
||||
clockContinuation?.resume(throwing: CancellationError())
|
||||
task.cancel()
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
group.cancelAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stateMachine.taskStarted(task, downstreamContinuation: downstreamContinuation)
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension Dictionary {
|
||||
/// Creates a new dictionary from the key-value pairs in the given asynchronous sequence.
|
||||
///
|
||||
@@ -20,14 +21,14 @@ extension Dictionary {
|
||||
///
|
||||
/// - Parameter keysAndValues: An asynchronous sequence of key-value pairs to use for
|
||||
/// the new dictionary. Every key in `keysAndValues` must be unique.
|
||||
/// - Returns: A new dictionary initialized with the elements of
|
||||
/// `keysAndValues`.
|
||||
/// - Precondition: The sequence must not have duplicate keys.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public init<S: AsyncSequence>(uniqueKeysWithValues keysAndValues: S) async rethrows where S.Element == (Key, Value) {
|
||||
public init<S: AsyncSequence>(uniqueKeysWithValues keysAndValues: S) async rethrows
|
||||
where S.Element == (Key, Value) {
|
||||
self.init(uniqueKeysWithValues: try await Array(keysAndValues))
|
||||
}
|
||||
|
||||
|
||||
/// Creates a new dictionary from the key-value pairs in the given asynchronous sequence,
|
||||
/// using a combining closure to determine the value for any duplicate keys.
|
||||
///
|
||||
@@ -46,8 +47,12 @@ extension Dictionary {
|
||||
/// keys that are encountered. The closure returns the desired value for
|
||||
/// the final dictionary, or throws an error if building the dictionary
|
||||
/// can't proceed.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public init<S: AsyncSequence>(_ keysAndValues: S, uniquingKeysWith combine: (Value, Value) async throws -> Value) async rethrows where S.Element == (Key, Value) {
|
||||
public init<S: AsyncSequence>(
|
||||
_ keysAndValues: S,
|
||||
uniquingKeysWith combine: (Value, Value) async throws -> Value
|
||||
) async rethrows where S.Element == (Key, Value) {
|
||||
self.init()
|
||||
for try await (key, value) in keysAndValues {
|
||||
if let existing = self[key] {
|
||||
@@ -57,7 +62,7 @@ extension Dictionary {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Creates a new dictionary whose keys are the groupings returned by the
|
||||
/// given closure and whose values are arrays of the elements that returned
|
||||
/// each key.
|
||||
@@ -70,8 +75,10 @@ extension Dictionary {
|
||||
/// - values: An asynchronous sequence of values to group into a dictionary.
|
||||
/// - keyForValue: A closure that returns a key for each element in
|
||||
/// `values`.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public init<S: AsyncSequence>(grouping values: S, by keyForValue: (S.Element) async throws -> Key) async rethrows where Value == [S.Element] {
|
||||
public init<S: AsyncSequence>(grouping values: S, by keyForValue: (S.Element) async throws -> Key) async rethrows
|
||||
where Value == [S.Element] {
|
||||
self.init()
|
||||
for try await value in values {
|
||||
let key = try await keyForValue(value)
|
||||
|
||||
@@ -9,145 +9,213 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequence {
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: "-")
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: The value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@inlinable
|
||||
public func interspersed(every: Int = 1, with separator: Element) -> AsyncInterspersedSequence<Self> {
|
||||
AsyncInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: "-")
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: The value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func interspersed(every: Int = 1, with separator: Element) -> AsyncInterspersedSequence<Self> {
|
||||
AsyncInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@inlinable
|
||||
public func interspersed(every: Int = 1, with separator: @Sendable @escaping () -> Element) -> AsyncInterspersedSequence<Self> {
|
||||
AsyncInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func interspersed(
|
||||
every: Int = 1,
|
||||
with separator: @Sendable @escaping () -> Element
|
||||
) -> AsyncInterspersedSequence<Self> {
|
||||
AsyncInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@inlinable
|
||||
public func interspersed(every: Int = 1, with separator: @Sendable @escaping () async -> Element) -> AsyncInterspersedSequence<Self> {
|
||||
AsyncInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func interspersed(
|
||||
every: Int = 1,
|
||||
with separator: @Sendable @escaping () async -> Element
|
||||
) -> AsyncInterspersedSequence<Self> {
|
||||
AsyncInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@inlinable
|
||||
public func interspersed(every: Int = 1, with separator: @Sendable @escaping () throws -> Element) -> AsyncThrowingInterspersedSequence<Self> {
|
||||
AsyncThrowingInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func interspersed(
|
||||
every: Int = 1,
|
||||
with separator: @Sendable @escaping () throws -> Element
|
||||
) -> AsyncThrowingInterspersedSequence<Self> {
|
||||
AsyncThrowingInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@inlinable
|
||||
public func interspersed(every: Int = 1, with separator: @Sendable @escaping () async throws -> Element) -> AsyncThrowingInterspersedSequence<Self> {
|
||||
AsyncThrowingInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
/// Returns a new asynchronous sequence containing the elements of this asynchronous sequence, inserting
|
||||
/// the given separator between each element.
|
||||
///
|
||||
/// Any value of this asynchronous sequence's element type can be used as the separator.
|
||||
///
|
||||
/// The following example shows how an async sequences of `String`s can be interspersed using `-` as the separator:
|
||||
///
|
||||
/// ```
|
||||
/// let input = ["A", "B", "C"].async
|
||||
/// let interspersed = input.interspersed(with: { "-" })
|
||||
/// for await element in interspersed {
|
||||
/// print(element)
|
||||
/// }
|
||||
/// // Prints "A" "-" "B" "-" "C"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - every: Dictates after how many elements a separator should be inserted.
|
||||
/// - separator: A closure that produces the value to insert in between each of this async sequence’s elements.
|
||||
/// - Returns: The interspersed asynchronous sequence of elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func interspersed(
|
||||
every: Int = 1,
|
||||
with separator: @Sendable @escaping () async throws -> Element
|
||||
) -> AsyncThrowingInterspersedSequence<Self> {
|
||||
AsyncThrowingInterspersedSequence(self, every: every, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
/// An asynchronous sequence that presents the elements of a base asynchronous sequence of
|
||||
/// elements with a separator between each of those elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncInterspersedSequence<Base: AsyncSequence> {
|
||||
@usableFromInline
|
||||
internal enum Separator {
|
||||
case element(Element)
|
||||
case syncClosure(@Sendable () -> Element)
|
||||
case asyncClosure(@Sendable () async -> Element)
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Separator
|
||||
|
||||
@usableFromInline
|
||||
internal let every: Int
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .element(separator)
|
||||
self.every = every
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .syncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () async -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .asyncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncInterspersedSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
/// The iterator for an `AsyncInterspersedSequence` asynchronous sequence.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
internal enum Separator {
|
||||
case element(Element)
|
||||
case syncClosure(@Sendable () -> Element)
|
||||
case asyncClosure(@Sendable () async -> Element)
|
||||
internal enum State {
|
||||
case start(Element?)
|
||||
case element(Int)
|
||||
case separator
|
||||
case finished
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
internal var iterator: Base.AsyncIterator
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Separator
|
||||
@@ -156,151 +224,144 @@ public struct AsyncInterspersedSequence<Base: AsyncSequence> {
|
||||
internal let every: Int
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .element(separator)
|
||||
self.every = every
|
||||
}
|
||||
internal var state = State.start(nil)
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .syncClosure(separator)
|
||||
self.every = every
|
||||
internal init(_ iterator: Base.AsyncIterator, every: Int, separator: Separator) {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
self.every = every
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () async -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .asyncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
}
|
||||
public mutating func next() async rethrows -> Base.Element? {
|
||||
switch self.state {
|
||||
case .start(var element):
|
||||
do {
|
||||
if element == nil {
|
||||
element = try await self.iterator.next()
|
||||
}
|
||||
|
||||
extension AsyncInterspersedSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
/// The iterator for an `AsyncInterspersedSequence` asynchronous sequence.
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
internal enum State {
|
||||
case start(Element?)
|
||||
case element(Int)
|
||||
case separator
|
||||
case finished
|
||||
guard let element = element else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
if self.every == 1 {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(1)
|
||||
}
|
||||
return element
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var iterator: Base.AsyncIterator
|
||||
case .separator:
|
||||
do {
|
||||
guard let element = try await iterator.next() else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
self.state = .start(element)
|
||||
switch self.separator {
|
||||
case .element(let element):
|
||||
return element
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Separator
|
||||
case .syncClosure(let closure):
|
||||
return closure()
|
||||
|
||||
@usableFromInline
|
||||
internal let every: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var state = State.start(nil)
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ iterator: Base.AsyncIterator, every: Int, separator: Separator) {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
self.every = every
|
||||
case .asyncClosure(let closure):
|
||||
return await closure()
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Base.Element? {
|
||||
switch self.state {
|
||||
case .start(var element):
|
||||
do {
|
||||
if element == nil {
|
||||
element = try await self.iterator.next()
|
||||
}
|
||||
|
||||
if let element = element {
|
||||
if self.every == 1 {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(1)
|
||||
}
|
||||
return element
|
||||
} else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .separator:
|
||||
do {
|
||||
if let element = try await iterator.next() {
|
||||
self.state = .start(element)
|
||||
switch self.separator {
|
||||
case .element(let element):
|
||||
return element
|
||||
|
||||
case .syncClosure(let closure):
|
||||
return closure()
|
||||
|
||||
case .asyncClosure(let closure):
|
||||
return await closure()
|
||||
}
|
||||
} else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .element(let count):
|
||||
do {
|
||||
if let element = try await iterator.next() {
|
||||
let newCount = count + 1
|
||||
if self.every == newCount {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(newCount)
|
||||
}
|
||||
return element
|
||||
} else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .finished:
|
||||
return nil
|
||||
}
|
||||
case .element(let count):
|
||||
do {
|
||||
guard let element = try await iterator.next() else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
let newCount = count + 1
|
||||
if self.every == newCount {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(newCount)
|
||||
}
|
||||
return element
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(self.base.makeAsyncIterator(), every: self.every, separator: self.separator)
|
||||
case .finished:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(self.base.makeAsyncIterator(), every: self.every, separator: self.separator)
|
||||
}
|
||||
}
|
||||
|
||||
/// An asynchronous sequence that presents the elements of a base asynchronous sequence of
|
||||
/// elements with a separator between each of those elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncThrowingInterspersedSequence<Base: AsyncSequence> {
|
||||
@usableFromInline
|
||||
internal enum Separator {
|
||||
case syncClosure(@Sendable () throws -> Element)
|
||||
case asyncClosure(@Sendable () async throws -> Element)
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Separator
|
||||
|
||||
@usableFromInline
|
||||
internal let every: Int
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () throws -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .syncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () async throws -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .asyncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingInterspersedSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
/// The iterator for an `AsyncInterspersedSequence` asynchronous sequence.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
internal enum Separator {
|
||||
case syncClosure(@Sendable () throws -> Element)
|
||||
case asyncClosure(@Sendable () async throws -> Element)
|
||||
internal enum State {
|
||||
case start(Element?)
|
||||
case element(Int)
|
||||
case separator
|
||||
case finished
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
internal var iterator: Base.AsyncIterator
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Separator
|
||||
@@ -309,133 +370,96 @@ public struct AsyncThrowingInterspersedSequence<Base: AsyncSequence> {
|
||||
internal let every: Int
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () throws -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .syncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
internal var state = State.start(nil)
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, every: Int, separator: @Sendable @escaping () async throws -> Element) {
|
||||
precondition(every > 0, "Separators can only be interspersed every 1+ elements")
|
||||
self.base = base
|
||||
self.separator = .asyncClosure(separator)
|
||||
self.every = every
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncThrowingInterspersedSequence: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
/// The iterator for an `AsyncInterspersedSequence` asynchronous sequence.
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
@usableFromInline
|
||||
internal enum State {
|
||||
case start(Element?)
|
||||
case element(Int)
|
||||
case separator
|
||||
case finished
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var iterator: Base.AsyncIterator
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Separator
|
||||
|
||||
@usableFromInline
|
||||
internal let every: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var state = State.start(nil)
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ iterator: Base.AsyncIterator, every: Int, separator: Separator) {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
self.every = every
|
||||
}
|
||||
|
||||
public mutating func next() async throws -> Base.Element? {
|
||||
switch self.state {
|
||||
case .start(var element):
|
||||
do {
|
||||
if element == nil {
|
||||
element = try await self.iterator.next()
|
||||
}
|
||||
|
||||
if let element = element {
|
||||
if self.every == 1 {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(1)
|
||||
}
|
||||
return element
|
||||
} else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .separator:
|
||||
do {
|
||||
if let element = try await iterator.next() {
|
||||
self.state = .start(element)
|
||||
switch self.separator {
|
||||
case .syncClosure(let closure):
|
||||
return try closure()
|
||||
|
||||
case .asyncClosure(let closure):
|
||||
return try await closure()
|
||||
}
|
||||
} else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .element(let count):
|
||||
do {
|
||||
if let element = try await iterator.next() {
|
||||
let newCount = count + 1
|
||||
if self.every == newCount {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(newCount)
|
||||
}
|
||||
return element
|
||||
} else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .finished:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(self.base.makeAsyncIterator(), every: self.every, separator: self.separator)
|
||||
internal init(_ iterator: Base.AsyncIterator, every: Int, separator: Separator) {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
self.every = every
|
||||
}
|
||||
|
||||
public mutating func next() async throws -> Base.Element? {
|
||||
switch self.state {
|
||||
case .start(var element):
|
||||
do {
|
||||
if element == nil {
|
||||
element = try await self.iterator.next()
|
||||
}
|
||||
|
||||
guard let element = element else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
if self.every == 1 {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(1)
|
||||
}
|
||||
return element
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .separator:
|
||||
do {
|
||||
guard let element = try await iterator.next() else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
self.state = .start(element)
|
||||
switch self.separator {
|
||||
case .syncClosure(let closure):
|
||||
return try closure()
|
||||
|
||||
case .asyncClosure(let closure):
|
||||
return try await closure()
|
||||
}
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .element(let count):
|
||||
do {
|
||||
guard let element = try await iterator.next() else {
|
||||
self.state = .finished
|
||||
return nil
|
||||
}
|
||||
let newCount = count + 1
|
||||
if self.every == newCount {
|
||||
self.state = .separator
|
||||
} else {
|
||||
self.state = .element(newCount)
|
||||
}
|
||||
return element
|
||||
} catch {
|
||||
self.state = .finished
|
||||
throw error
|
||||
}
|
||||
|
||||
case .finished:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@inlinable
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(self.base.makeAsyncIterator(), every: self.every, separator: self.separator)
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncInterspersedSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncInterspersedSequence.Separator: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingInterspersedSequence: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncThrowingInterspersedSequence.Separator: Sendable where Base: Sendable, Base.Element: Sendable {}
|
||||
|
||||
@available(*, unavailable)
|
||||
|
||||
@@ -24,67 +24,67 @@ import Bionic
|
||||
#endif
|
||||
|
||||
internal struct Lock {
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
typealias Primitive = os_unfair_lock
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
typealias Primitive = pthread_mutex_t
|
||||
#elseif canImport(WinSDK)
|
||||
#elseif canImport(WinSDK)
|
||||
typealias Primitive = SRWLOCK
|
||||
#else
|
||||
#else
|
||||
#error("Unsupported platform")
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
typealias PlatformLock = UnsafeMutablePointer<Primitive>
|
||||
let platformLock: PlatformLock
|
||||
|
||||
private init(_ platformLock: PlatformLock) {
|
||||
self.platformLock = platformLock
|
||||
}
|
||||
|
||||
|
||||
fileprivate static func initialize(_ platformLock: PlatformLock) {
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
platformLock.initialize(to: os_unfair_lock())
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
let result = pthread_mutex_init(platformLock, nil)
|
||||
precondition(result == 0, "pthread_mutex_init failed")
|
||||
#elseif canImport(WinSDK)
|
||||
#elseif canImport(WinSDK)
|
||||
InitializeSRWLock(platformLock)
|
||||
#else
|
||||
#else
|
||||
#error("Unsupported platform")
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
fileprivate static func deinitialize(_ platformLock: PlatformLock) {
|
||||
#if canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#if canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
let result = pthread_mutex_destroy(platformLock)
|
||||
precondition(result == 0, "pthread_mutex_destroy failed")
|
||||
#endif
|
||||
#endif
|
||||
platformLock.deinitialize(count: 1)
|
||||
}
|
||||
|
||||
|
||||
fileprivate static func lock(_ platformLock: PlatformLock) {
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
os_unfair_lock_lock(platformLock)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
pthread_mutex_lock(platformLock)
|
||||
#elseif canImport(WinSDK)
|
||||
#elseif canImport(WinSDK)
|
||||
AcquireSRWLockExclusive(platformLock)
|
||||
#else
|
||||
#else
|
||||
#error("Unsupported platform")
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
fileprivate static func unlock(_ platformLock: PlatformLock) {
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
os_unfair_lock_unlock(platformLock)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
let result = pthread_mutex_unlock(platformLock)
|
||||
precondition(result == 0, "pthread_mutex_unlock failed")
|
||||
#elseif canImport(WinSDK)
|
||||
#elseif canImport(WinSDK)
|
||||
ReleaseSRWLockExclusive(platformLock)
|
||||
#else
|
||||
#else
|
||||
#error("Unsupported platform")
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
static func allocate() -> Lock {
|
||||
@@ -106,26 +106,26 @@ internal struct Lock {
|
||||
Lock.unlock(platformLock)
|
||||
}
|
||||
|
||||
/// Acquire the lock for the duration of the given block.
|
||||
///
|
||||
/// This convenience method should be preferred to `lock` and `unlock` in
|
||||
/// most situations, as it ensures that the lock will be released regardless
|
||||
/// of how `body` exits.
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
func withLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
self.lock()
|
||||
defer {
|
||||
self.unlock()
|
||||
}
|
||||
return try body()
|
||||
/// Acquire the lock for the duration of the given block.
|
||||
///
|
||||
/// This convenience method should be preferred to `lock` and `unlock` in
|
||||
/// most situations, as it ensures that the lock will be released regardless
|
||||
/// of how `body` exits.
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
func withLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
self.lock()
|
||||
defer {
|
||||
self.unlock()
|
||||
}
|
||||
return try body()
|
||||
}
|
||||
|
||||
// specialise Void return (for performance)
|
||||
func withLockVoid(_ body: () throws -> Void) rethrows -> Void {
|
||||
try self.withLock(body)
|
||||
}
|
||||
// specialise Void return (for performance)
|
||||
func withLockVoid(_ body: () throws -> Void) rethrows {
|
||||
try self.withLock(body)
|
||||
}
|
||||
}
|
||||
|
||||
struct ManagedCriticalState<State> {
|
||||
@@ -134,16 +134,16 @@ struct ManagedCriticalState<State> {
|
||||
withUnsafeMutablePointerToElements { Lock.deinitialize($0) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private let buffer: ManagedBuffer<State, Lock.Primitive>
|
||||
|
||||
|
||||
init(_ initial: State) {
|
||||
buffer = LockedBuffer.create(minimumCapacity: 1) { buffer in
|
||||
buffer.withUnsafeMutablePointerToElements { Lock.initialize($0) }
|
||||
return initial
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func withCriticalRegion<R>(_ critical: (inout State) throws -> R) rethrows -> R {
|
||||
try buffer.withUnsafeMutablePointers { header, lock in
|
||||
Lock.lock(lock)
|
||||
@@ -153,4 +153,4 @@ struct ManagedCriticalState<State> {
|
||||
}
|
||||
}
|
||||
|
||||
extension ManagedCriticalState: @unchecked Sendable where State: Sendable { }
|
||||
extension ManagedCriticalState: @unchecked Sendable where State: Sendable {}
|
||||
@@ -12,86 +12,98 @@
|
||||
import DequeModule
|
||||
|
||||
/// Creates an asynchronous sequence of elements from two underlying asynchronous sequences
|
||||
public func merge<Base1: AsyncSequence, Base2: AsyncSequence>(_ base1: Base1, _ base2: Base2) -> AsyncMerge2Sequence<Base1, Base2>
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1: Sendable, Base2: Sendable,
|
||||
Base1.Element: Sendable
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func merge<Base1: AsyncSequence, Base2: AsyncSequence>(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2
|
||||
) -> AsyncMerge2Sequence<Base1, Base2>
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base1.Element: Sendable
|
||||
{
|
||||
return AsyncMerge2Sequence(base1, base2)
|
||||
return AsyncMerge2Sequence(base1, base2)
|
||||
}
|
||||
|
||||
/// An ``Swift/AsyncSequence`` that takes two upstream ``Swift/AsyncSequence``s and combines their elements.
|
||||
/// An `AsyncSequence` that takes two upstream `AsyncSequence`s and combines their elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncMerge2Sequence<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence
|
||||
>: Sendable where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1: Sendable, Base2: Sendable,
|
||||
Base1.Element: Sendable
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence
|
||||
>: Sendable
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base1.Element: Sendable
|
||||
{
|
||||
public typealias Element = Base1.Element
|
||||
public typealias Element = Base1.Element
|
||||
|
||||
private let base1: Base1
|
||||
private let base2: Base2
|
||||
private let base1: Base1
|
||||
private let base2: Base2
|
||||
|
||||
/// Initializes a new ``AsyncMerge2Sequence``.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - base1: The first upstream ``Swift/AsyncSequence``.
|
||||
/// - base2: The second upstream ``Swift/AsyncSequence``.
|
||||
init(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2
|
||||
) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
}
|
||||
/// Initializes a new ``AsyncMerge2Sequence``.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - base1: The first upstream ``Swift/AsyncSequence``.
|
||||
/// - base2: The second upstream ``Swift/AsyncSequence``.
|
||||
init(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2
|
||||
) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncMerge2Sequence: AsyncSequence {
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storage = MergeStorage<Base1, Base2, Base1>(
|
||||
base1: base1,
|
||||
base2: base2,
|
||||
base3: nil
|
||||
)
|
||||
return Iterator(storage: storage)
|
||||
}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storage = MergeStorage<Base1, Base2, Base1>(
|
||||
base1: base1,
|
||||
base2: base2,
|
||||
base3: nil
|
||||
)
|
||||
return Iterator(storage: storage)
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncMerge2Sequence {
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
/// This class is needed to hook the deinit to observe once all references to the ``AsyncIterator`` are dropped.
|
||||
///
|
||||
/// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncIterator`` struct itself.
|
||||
final class InternalClass: Sendable {
|
||||
private let storage: MergeStorage<Base1, Base2, Base1>
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
/// This class is needed to hook the deinit to observe once all references to the ``AsyncIterator`` are dropped.
|
||||
///
|
||||
/// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncIterator`` struct itself.
|
||||
final class InternalClass: Sendable {
|
||||
private let storage: MergeStorage<Base1, Base2, Base1>
|
||||
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base1>) {
|
||||
self.storage = storage
|
||||
}
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base1>) {
|
||||
self.storage = storage
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.storage.iteratorDeinitialized()
|
||||
}
|
||||
deinit {
|
||||
self.storage.iteratorDeinitialized()
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
try await storage.next()
|
||||
}
|
||||
}
|
||||
|
||||
let internalClass: InternalClass
|
||||
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base1>) {
|
||||
internalClass = InternalClass(storage: storage)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
try await internalClass.next()
|
||||
}
|
||||
func next() async rethrows -> Element? {
|
||||
try await storage.next()
|
||||
}
|
||||
}
|
||||
|
||||
let internalClass: InternalClass
|
||||
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base1>) {
|
||||
internalClass = InternalClass(storage: storage)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
try await internalClass.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncMerge2Sequence.Iterator: Sendable { }
|
||||
extension AsyncMerge2Sequence.Iterator: Sendable {}
|
||||
@@ -12,97 +12,108 @@
|
||||
import DequeModule
|
||||
|
||||
/// Creates an asynchronous sequence of elements from two underlying asynchronous sequences
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func merge<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>(_ base1: Base1, _ base2: Base2, _ base3: Base3) -> AsyncMerge3Sequence<Base1, Base2, Base3>
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1.Element == Base3.Element,
|
||||
Base1: Sendable, Base2: Sendable, Base3: Sendable,
|
||||
Base1.Element: Sendable
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1.Element == Base3.Element,
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base3: Sendable,
|
||||
Base1.Element: Sendable
|
||||
{
|
||||
return AsyncMerge3Sequence(base1, base2, base3)
|
||||
return AsyncMerge3Sequence(base1, base2, base3)
|
||||
}
|
||||
|
||||
/// An ``Swift/AsyncSequence`` that takes three upstream ``Swift/AsyncSequence``s and combines their elements.
|
||||
/// An `AsyncSequence` that takes three upstream `AsyncSequence`s and combines their elements.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncMerge3Sequence<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: Sendable where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1.Element == Base3.Element,
|
||||
Base1: Sendable, Base2: Sendable, Base3: Sendable,
|
||||
Base1.Element: Sendable
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: Sendable
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1.Element == Base3.Element,
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base3: Sendable,
|
||||
Base1.Element: Sendable
|
||||
{
|
||||
public typealias Element = Base1.Element
|
||||
public typealias Element = Base1.Element
|
||||
|
||||
private let base1: Base1
|
||||
private let base2: Base2
|
||||
private let base3: Base3
|
||||
private let base1: Base1
|
||||
private let base2: Base2
|
||||
private let base3: Base3
|
||||
|
||||
/// Initializes a new ``AsyncMerge2Sequence``.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - base1: The first upstream ``Swift/AsyncSequence``.
|
||||
/// - base2: The second upstream ``Swift/AsyncSequence``.
|
||||
/// - base3: The third upstream ``Swift/AsyncSequence``.
|
||||
init(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2,
|
||||
_ base3: Base3
|
||||
) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
self.base3 = base3
|
||||
}
|
||||
/// Initializes a new ``AsyncMerge2Sequence``.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - base1: The first upstream ``Swift/AsyncSequence``.
|
||||
/// - base2: The second upstream ``Swift/AsyncSequence``.
|
||||
/// - base3: The third upstream ``Swift/AsyncSequence``.
|
||||
init(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2,
|
||||
_ base3: Base3
|
||||
) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
self.base3 = base3
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncMerge3Sequence: AsyncSequence {
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storage = MergeStorage(
|
||||
base1: base1,
|
||||
base2: base2,
|
||||
base3: base3
|
||||
)
|
||||
return Iterator(storage: storage)
|
||||
}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storage = MergeStorage(
|
||||
base1: base1,
|
||||
base2: base2,
|
||||
base3: base3
|
||||
)
|
||||
return Iterator(storage: storage)
|
||||
}
|
||||
}
|
||||
|
||||
public extension AsyncMerge3Sequence {
|
||||
struct Iterator: AsyncIteratorProtocol {
|
||||
/// This class is needed to hook the deinit to observe once all references to the ``AsyncIterator`` are dropped.
|
||||
///
|
||||
/// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncIterator`` struct itself.
|
||||
final class InternalClass: Sendable {
|
||||
private let storage: MergeStorage<Base1, Base2, Base3>
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncMerge3Sequence {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
/// This class is needed to hook the deinit to observe once all references to the ``AsyncIterator`` are dropped.
|
||||
///
|
||||
/// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncIterator`` struct itself.
|
||||
final class InternalClass: Sendable {
|
||||
private let storage: MergeStorage<Base1, Base2, Base3>
|
||||
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base3>) {
|
||||
self.storage = storage
|
||||
}
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base3>) {
|
||||
self.storage = storage
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.storage.iteratorDeinitialized()
|
||||
}
|
||||
deinit {
|
||||
self.storage.iteratorDeinitialized()
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
try await storage.next()
|
||||
}
|
||||
}
|
||||
|
||||
let internalClass: InternalClass
|
||||
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base3>) {
|
||||
internalClass = InternalClass(storage: storage)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
try await internalClass.next()
|
||||
}
|
||||
func next() async rethrows -> Element? {
|
||||
try await storage.next()
|
||||
}
|
||||
}
|
||||
|
||||
let internalClass: InternalClass
|
||||
|
||||
fileprivate init(storage: MergeStorage<Base1, Base2, Base3>) {
|
||||
internalClass = InternalClass(storage: storage)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
try await internalClass.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncMerge3Sequence.Iterator: Sendable { }
|
||||
extension AsyncMerge3Sequence.Iterator: Sendable {}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -9,280 +9,288 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
final class MergeStorage<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: @unchecked Sendable where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1.Element == Base3.Element,
|
||||
Base1: Sendable, Base2: Sendable, Base3: Sendable,
|
||||
Base1.Element: Sendable
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: @unchecked Sendable
|
||||
where
|
||||
Base1.Element == Base2.Element,
|
||||
Base1.Element == Base3.Element,
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base3: Sendable,
|
||||
Base1.Element: Sendable
|
||||
{
|
||||
typealias Element = Base1.Element
|
||||
typealias Element = Base1.Element
|
||||
|
||||
/// The lock that protects our state.
|
||||
private let lock = Lock.allocate()
|
||||
/// The state machine.
|
||||
private var stateMachine: MergeStateMachine<Base1, Base2, Base3>
|
||||
/// The lock that protects our state.
|
||||
private let lock = Lock.allocate()
|
||||
/// The state machine.
|
||||
private var stateMachine: MergeStateMachine<Base1, Base2, Base3>
|
||||
|
||||
init(
|
||||
base1: Base1,
|
||||
base2: Base2,
|
||||
base3: Base3?
|
||||
) {
|
||||
stateMachine = .init(base1: base1, base2: base2, base3: base3)
|
||||
init(
|
||||
base1: Base1,
|
||||
base2: Base2,
|
||||
base3: Base3?
|
||||
) {
|
||||
stateMachine = .init(base1: base1, base2: base2, base3: base3)
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.lock.deinitialize()
|
||||
}
|
||||
|
||||
func iteratorDeinitialized() {
|
||||
let action = lock.withLock { self.stateMachine.iteratorDeinitialized() }
|
||||
|
||||
switch action {
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
// We need to handle cancellation here because we are creating a continuation
|
||||
// and because we need to cancel the `Task` we created to consume the upstream
|
||||
try await withTaskCancellationHandler {
|
||||
self.lock.lock()
|
||||
let action = self.stateMachine.next()
|
||||
|
||||
switch action {
|
||||
case .startTaskAndSuspendDownstreamTask(let base1, let base2, let base3):
|
||||
self.startTask(
|
||||
stateMachine: &self.stateMachine,
|
||||
base1: base1,
|
||||
base2: base2,
|
||||
base3: base3
|
||||
)
|
||||
// It is safe to hold the lock across this method
|
||||
// since the closure is guaranteed to be run straight away
|
||||
return try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.next(for: continuation)
|
||||
self.lock.unlock()
|
||||
|
||||
switch action {
|
||||
case let .resumeUpstreamContinuations(upstreamContinuations):
|
||||
// This is signalling the child tasks that are consuming the upstream
|
||||
// sequences to signal demand.
|
||||
upstreamContinuations.forEach { $0.resume(returning: ()) }
|
||||
}
|
||||
}
|
||||
|
||||
case let .returnElement(element):
|
||||
self.lock.unlock()
|
||||
|
||||
return try element._rethrowGet()
|
||||
|
||||
case .returnNil:
|
||||
self.lock.unlock()
|
||||
return nil
|
||||
|
||||
case let .throwError(error):
|
||||
self.lock.unlock()
|
||||
throw error
|
||||
|
||||
case .suspendDownstreamTask:
|
||||
// It is safe to hold the lock across this method
|
||||
// since the closure is guaranteed to be run straight away
|
||||
return try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.next(for: continuation)
|
||||
self.lock.unlock()
|
||||
|
||||
switch action {
|
||||
case let .resumeUpstreamContinuations(upstreamContinuations):
|
||||
// This is signalling the child tasks that are consuming the upstream
|
||||
// sequences to signal demand.
|
||||
upstreamContinuations.forEach { $0.resume(returning: ()) }
|
||||
}
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
let action = self.lock.withLock { self.stateMachine.cancelled() }
|
||||
|
||||
switch action {
|
||||
case let .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation,
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: nil)
|
||||
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func startTask(
|
||||
stateMachine: inout MergeStateMachine<Base1, Base2, Base3>,
|
||||
base1: Base1,
|
||||
base2: Base2,
|
||||
base3: Base3?
|
||||
) {
|
||||
// This creates a new `Task` that is iterating the upstream
|
||||
// sequences. We must store it to cancel it at the right times.
|
||||
let task = Task {
|
||||
await withThrowingTaskGroup(of: Void.self) { group in
|
||||
self.iterateAsyncSequence(base1, in: &group)
|
||||
self.iterateAsyncSequence(base2, in: &group)
|
||||
|
||||
// Copy from the above just using the base3 sequence
|
||||
if let base3 = base3 {
|
||||
self.iterateAsyncSequence(base3, in: &group)
|
||||
}
|
||||
|
||||
while !group.isEmpty {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.upstreamThrew(error)
|
||||
}
|
||||
switch action {
|
||||
case let .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation,
|
||||
error,
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(throwing: error)
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
group.cancelAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.lock.deinitialize()
|
||||
}
|
||||
// We need to inform our state machine that we started the Task
|
||||
stateMachine.taskStarted(task)
|
||||
}
|
||||
|
||||
func iteratorDeinitialized() {
|
||||
let action = lock.withLock { self.stateMachine.iteratorDeinitialized() }
|
||||
private func iterateAsyncSequence<AsyncSequence: _Concurrency.AsyncSequence>(
|
||||
_ base: AsyncSequence,
|
||||
in taskGroup: inout ThrowingTaskGroup<Void, Error>
|
||||
) where AsyncSequence.Element == Base1.Element, AsyncSequence: Sendable {
|
||||
// For each upstream sequence we are adding a child task that
|
||||
// is consuming the upstream sequence
|
||||
taskGroup.addTask {
|
||||
var iterator = base.makeAsyncIterator()
|
||||
|
||||
switch action {
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
// This is our upstream consumption loop
|
||||
loop: while true {
|
||||
// We are creating a continuation before requesting the next
|
||||
// element from upstream. This continuation is only resumed
|
||||
// if the downstream consumer called `next` to signal his demand.
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.childTaskSuspended(continuation)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case let .resumeContinuation(continuation):
|
||||
// This happens if there is outstanding demand
|
||||
// and we need to demand from upstream right away
|
||||
continuation.resume(returning: ())
|
||||
|
||||
case let .resumeContinuationWithError(continuation, error):
|
||||
// This happens if another upstream already failed or if
|
||||
// the task got cancelled.
|
||||
continuation.resume(throwing: error)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// We got signalled from the downstream that we have demand so let's
|
||||
// request a new element from the upstream
|
||||
if let element1 = try await iterator.next() {
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.elementProduced(element1)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case let .resumeContinuation(continuation, element):
|
||||
// We had an outstanding demand and where the first
|
||||
// upstream to produce an element so we can forward it to
|
||||
// the downstream
|
||||
continuation.resume(returning: element)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
} else {
|
||||
// The upstream returned `nil` which indicates that it finished
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.upstreamFinished()
|
||||
}
|
||||
|
||||
// All of this is mostly cleanup around the Task and the outstanding
|
||||
// continuations used for signalling.
|
||||
switch action {
|
||||
case let .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation,
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
// We need to handle cancellation here because we are creating a continuation
|
||||
// and because we need to cancel the `Task` we created to consume the upstream
|
||||
try await withTaskCancellationHandler {
|
||||
self.lock.lock()
|
||||
let action = self.stateMachine.next()
|
||||
|
||||
switch action {
|
||||
case .startTaskAndSuspendDownstreamTask(let base1, let base2, let base3):
|
||||
self.startTask(
|
||||
stateMachine: &self.stateMachine,
|
||||
base1: base1,
|
||||
base2: base2,
|
||||
base3: base3
|
||||
)
|
||||
// It is safe to hold the lock across this method
|
||||
// since the closure is guaranteed to be run straight away
|
||||
return try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.next(for: continuation)
|
||||
self.lock.unlock()
|
||||
|
||||
switch action {
|
||||
case let .resumeUpstreamContinuations(upstreamContinuations):
|
||||
// This is signalling the child tasks that are consuming the upstream
|
||||
// sequences to signal demand.
|
||||
upstreamContinuations.forEach { $0.resume(returning: ()) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
case let .returnElement(element):
|
||||
self.lock.unlock()
|
||||
|
||||
return try element._rethrowGet()
|
||||
|
||||
case .returnNil:
|
||||
self.lock.unlock()
|
||||
return nil
|
||||
|
||||
case let .throwError(error):
|
||||
self.lock.unlock()
|
||||
throw error
|
||||
|
||||
case .suspendDownstreamTask:
|
||||
// It is safe to hold the lock across this method
|
||||
// since the closure is guaranteed to be run straight away
|
||||
return try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.stateMachine.next(for: continuation)
|
||||
self.lock.unlock()
|
||||
|
||||
switch action {
|
||||
case let .resumeUpstreamContinuations(upstreamContinuations):
|
||||
// This is signalling the child tasks that are consuming the upstream
|
||||
// sequences to signal demand.
|
||||
upstreamContinuations.forEach { $0.resume(returning: ()) }
|
||||
}
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
let action = self.lock.withLock { self.stateMachine.cancelled() }
|
||||
|
||||
switch action {
|
||||
case let .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation,
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: nil)
|
||||
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func startTask(stateMachine: inout MergeStateMachine<Base1, Base2, Base3>, base1: Base1, base2: Base2, base3: Base3?) {
|
||||
// This creates a new `Task` that is iterating the upstream
|
||||
// sequences. We must store it to cancel it at the right times.
|
||||
let task = Task {
|
||||
await withThrowingTaskGroup(of: Void.self) { group in
|
||||
self.iterateAsyncSequence(base1, in: &group)
|
||||
self.iterateAsyncSequence(base2, in: &group)
|
||||
|
||||
// Copy from the above just using the base3 sequence
|
||||
if let base3 = base3 {
|
||||
self.iterateAsyncSequence(base3, in: &group)
|
||||
}
|
||||
|
||||
while !group.isEmpty {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.upstreamThrew(error)
|
||||
}
|
||||
switch action {
|
||||
case let .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation,
|
||||
error,
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(throwing: error)
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
|
||||
task.cancel()
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
group.cancelAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// We need to inform our state machine that we started the Task
|
||||
stateMachine.taskStarted(task)
|
||||
}
|
||||
|
||||
private func iterateAsyncSequence<AsyncSequence: _Concurrency.AsyncSequence>(
|
||||
_ base: AsyncSequence,
|
||||
in taskGroup: inout ThrowingTaskGroup<Void, Error>
|
||||
) where AsyncSequence.Element == Base1.Element, AsyncSequence: Sendable {
|
||||
// For each upstream sequence we are adding a child task that
|
||||
// is consuming the upstream sequence
|
||||
taskGroup.addTask {
|
||||
var iterator = base.makeAsyncIterator()
|
||||
|
||||
// This is our upstream consumption loop
|
||||
loop: while true {
|
||||
// We are creating a continuation before requesting the next
|
||||
// element from upstream. This continuation is only resumed
|
||||
// if the downstream consumer called `next` to signal his demand.
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.childTaskSuspended(continuation)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case let .resumeContinuation(continuation):
|
||||
// This happens if there is outstanding demand
|
||||
// and we need to demand from upstream right away
|
||||
continuation.resume(returning: ())
|
||||
|
||||
case let .resumeContinuationWithError(continuation, error):
|
||||
// This happens if another upstream already failed or if
|
||||
// the task got cancelled.
|
||||
continuation.resume(throwing: error)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// We got signalled from the downstream that we have demand so let's
|
||||
// request a new element from the upstream
|
||||
if let element1 = try await iterator.next() {
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.elementProduced(element1)
|
||||
}
|
||||
|
||||
switch action {
|
||||
case let .resumeContinuation(continuation, element):
|
||||
// We had an outstanding demand and where the first
|
||||
// upstream to produce an element so we can forward it to
|
||||
// the downstream
|
||||
continuation.resume(returning: element)
|
||||
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
} else {
|
||||
// The upstream returned `nil` which indicates that it finished
|
||||
let action = self.lock.withLock {
|
||||
self.stateMachine.upstreamFinished()
|
||||
}
|
||||
|
||||
// All of this is mostly cleanup around the Task and the outstanding
|
||||
// continuations used for signalling.
|
||||
switch action {
|
||||
case let .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation,
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: nil)
|
||||
|
||||
break loop
|
||||
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
|
||||
break loop
|
||||
case .none:
|
||||
|
||||
break loop
|
||||
}
|
||||
}
|
||||
}
|
||||
downstreamContinuation.resume(returning: nil)
|
||||
|
||||
break loop
|
||||
|
||||
case let .cancelTaskAndUpstreamContinuations(
|
||||
task,
|
||||
upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
|
||||
break loop
|
||||
case .none:
|
||||
|
||||
break loop
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension RangeReplaceableCollection {
|
||||
/// Creates a new instance of a collection containing the elements of an asynchronous sequence.
|
||||
///
|
||||
|
||||
@@ -25,11 +25,10 @@ extension _ErrorMechanism {
|
||||
_ = try _rethrowGet()
|
||||
fatalError("materialized error without being in a throwing context")
|
||||
}
|
||||
|
||||
|
||||
internal func _rethrowGet() rethrows -> Output {
|
||||
return try get()
|
||||
}
|
||||
}
|
||||
|
||||
extension Result: _ErrorMechanism { }
|
||||
|
||||
extension Result: _ErrorMechanism {}
|
||||
@@ -9,11 +9,12 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension SetAlgebra {
|
||||
/// Creates a new set from an asynchronous sequence of items.
|
||||
///
|
||||
/// Use this initializer to create a new set from an asynchronous sequence
|
||||
///
|
||||
///
|
||||
/// - Parameter source: The elements to use as members of the new set.
|
||||
@inlinable
|
||||
public init<Source: AsyncSequence>(_ source: Source) async rethrows where Source.Element == Element {
|
||||
|
||||
@@ -11,9 +11,9 @@
|
||||
|
||||
/// A wrapper struct to unconditionally to transfer an non-Sendable value.
|
||||
struct UnsafeTransfer<Element>: @unchecked Sendable {
|
||||
let wrapped: Element
|
||||
let wrapped: Element
|
||||
|
||||
init(_ wrapped: Element) {
|
||||
self.wrapped = wrapped
|
||||
}
|
||||
init(_ wrapped: Element) {
|
||||
self.wrapped = wrapped
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@
|
||||
|
||||
/// Creates an asynchronous sequence that concurrently awaits values from two `AsyncSequence` types
|
||||
/// and emits a tuple of the values.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func zip<Base1: AsyncSequence, Base2: AsyncSequence>(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2
|
||||
@@ -20,8 +21,9 @@ public func zip<Base1: AsyncSequence, Base2: AsyncSequence>(
|
||||
|
||||
/// An asynchronous sequence that concurrently awaits values from two `AsyncSequence` types
|
||||
/// and emits a tuple of the values.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncZip2Sequence<Base1: AsyncSequence, Base2: AsyncSequence>: AsyncSequence, Sendable
|
||||
where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable {
|
||||
where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable {
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
@@ -71,4 +73,4 @@ public struct AsyncZip2Sequence<Base1: AsyncSequence, Base2: AsyncSequence>: Asy
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncZip2Sequence.Iterator: Sendable { }
|
||||
extension AsyncZip2Sequence.Iterator: Sendable {}
|
||||
@@ -11,6 +11,7 @@
|
||||
|
||||
/// Creates an asynchronous sequence that concurrently awaits values from three `AsyncSequence` types
|
||||
/// and emits a tuple of the values.
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func zip<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>(
|
||||
_ base1: Base1,
|
||||
_ base2: Base2,
|
||||
@@ -21,8 +22,17 @@ public func zip<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence
|
||||
|
||||
/// An asynchronous sequence that concurrently awaits values from three `AsyncSequence` types
|
||||
/// and emits a tuple of the values.
|
||||
public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: AsyncSequence, Sendable
|
||||
where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable, Base3: Sendable, Base3.Element: Sendable {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: AsyncSequence,
|
||||
Sendable
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3: Sendable,
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
public typealias Element = (Base1.Element, Base2.Element, Base3.Element)
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
@@ -37,7 +47,8 @@ public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> AsyncIterator {
|
||||
Iterator(storage: .init(self.base1, self.base2, self.base3)
|
||||
Iterator(
|
||||
storage: .init(self.base1, self.base2, self.base3)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -76,4 +87,4 @@ public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncZip3Sequence.Iterator: Sendable { }
|
||||
extension AsyncZip3Sequence.Iterator: Sendable {}
|
||||
@@ -10,22 +10,29 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// State machine for zip
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct ZipStateMachine<
|
||||
Base1: AsyncSequence,
|
||||
Base2: AsyncSequence,
|
||||
Base3: AsyncSequence
|
||||
>: Sendable where
|
||||
>: Sendable
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base2: Sendable,
|
||||
Base3: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3.Element: Sendable {
|
||||
typealias DownstreamContinuation = UnsafeContinuation<Result<(
|
||||
Base1.Element,
|
||||
Base2.Element,
|
||||
Base3.Element?
|
||||
)?, Error>, Never>
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
typealias DownstreamContinuation = UnsafeContinuation<
|
||||
Result<
|
||||
(
|
||||
Base1.Element,
|
||||
Base2.Element,
|
||||
Base3.Element?
|
||||
)?, Error
|
||||
>, Never
|
||||
>
|
||||
|
||||
private enum State: Sendable {
|
||||
/// Small wrapper for the state of an upstream sequence.
|
||||
@@ -101,7 +108,9 @@ struct ZipStateMachine<
|
||||
|
||||
case .zipping:
|
||||
// An iterator was deinitialized while we have a suspended continuation.
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received iteratorDeinitialized()")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received iteratorDeinitialized()"
|
||||
)
|
||||
|
||||
case .waitingForDemand(let task, let upstreams):
|
||||
// The iterator was dropped which signals that the consumer is finished.
|
||||
@@ -110,7 +119,8 @@ struct ZipStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .finished:
|
||||
@@ -159,7 +169,10 @@ struct ZipStateMachine<
|
||||
)
|
||||
}
|
||||
|
||||
mutating func childTaskSuspended(baseIndex: Int, continuation: UnsafeContinuation<Void, Error>) -> ChildTaskSuspendedAction? {
|
||||
mutating func childTaskSuspended(
|
||||
baseIndex: Int,
|
||||
continuation: UnsafeContinuation<Void, Error>
|
||||
) -> ChildTaskSuspendedAction? {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
// Child tasks are only created after we transitioned to `zipping`
|
||||
@@ -179,7 +192,9 @@ struct ZipStateMachine<
|
||||
upstreams.2.continuation = continuation
|
||||
|
||||
default:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received childTaskSuspended() with base index \(baseIndex)")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received childTaskSuspended() with base index \(baseIndex)"
|
||||
)
|
||||
}
|
||||
|
||||
self.state = .waitingForDemand(
|
||||
@@ -194,9 +209,7 @@ struct ZipStateMachine<
|
||||
// already then we store the continuation otherwise we just go ahead and resume it
|
||||
switch baseIndex {
|
||||
case 0:
|
||||
if upstreams.0.element == nil {
|
||||
return .resumeContinuation(upstreamContinuation: continuation)
|
||||
} else {
|
||||
guard upstreams.0.element == nil else {
|
||||
self.state = .modifying
|
||||
upstreams.0.continuation = continuation
|
||||
self.state = .zipping(
|
||||
@@ -206,11 +219,10 @@ struct ZipStateMachine<
|
||||
)
|
||||
return .none
|
||||
}
|
||||
return .resumeContinuation(upstreamContinuation: continuation)
|
||||
|
||||
case 1:
|
||||
if upstreams.1.element == nil {
|
||||
return .resumeContinuation(upstreamContinuation: continuation)
|
||||
} else {
|
||||
guard upstreams.1.element == nil else {
|
||||
self.state = .modifying
|
||||
upstreams.1.continuation = continuation
|
||||
self.state = .zipping(
|
||||
@@ -220,11 +232,10 @@ struct ZipStateMachine<
|
||||
)
|
||||
return .none
|
||||
}
|
||||
return .resumeContinuation(upstreamContinuation: continuation)
|
||||
|
||||
case 2:
|
||||
if upstreams.2.element == nil {
|
||||
return .resumeContinuation(upstreamContinuation: continuation)
|
||||
} else {
|
||||
guard upstreams.2.element == nil else {
|
||||
self.state = .modifying
|
||||
upstreams.2.continuation = continuation
|
||||
self.state = .zipping(
|
||||
@@ -234,9 +245,12 @@ struct ZipStateMachine<
|
||||
)
|
||||
return .none
|
||||
}
|
||||
return .resumeContinuation(upstreamContinuation: continuation)
|
||||
|
||||
default:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received childTaskSuspended() with base index \(baseIndex)")
|
||||
preconditionFailure(
|
||||
"Internal inconsistency current state \(self.state) and received childTaskSuspended() with base index \(baseIndex)"
|
||||
)
|
||||
}
|
||||
|
||||
case .finished:
|
||||
@@ -295,8 +309,9 @@ struct ZipStateMachine<
|
||||
|
||||
// Implementing this for the two arities without variadic generics is a bit awkward sadly.
|
||||
if let first = upstreams.0.element,
|
||||
let second = upstreams.1.element,
|
||||
let third = upstreams.2.element {
|
||||
let second = upstreams.1.element,
|
||||
let third = upstreams.2.element
|
||||
{
|
||||
// We got an element from each upstream so we can resume the downstream now
|
||||
self.state = .waitingForDemand(
|
||||
task: task,
|
||||
@@ -313,8 +328,9 @@ struct ZipStateMachine<
|
||||
)
|
||||
|
||||
} else if let first = upstreams.0.element,
|
||||
let second = upstreams.1.element,
|
||||
self.numberOfUpstreamSequences == 2 {
|
||||
let second = upstreams.1.element,
|
||||
self.numberOfUpstreamSequences == 2
|
||||
{
|
||||
// We got an element from each upstream so we can resume the downstream now
|
||||
self.state = .waitingForDemand(
|
||||
task: task,
|
||||
@@ -385,7 +401,8 @@ struct ZipStateMachine<
|
||||
return .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .finished:
|
||||
@@ -429,7 +446,8 @@ struct ZipStateMachine<
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
error: error,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .finished:
|
||||
@@ -460,9 +478,9 @@ struct ZipStateMachine<
|
||||
mutating func cancelled() -> CancelledAction? {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
state = .finished
|
||||
state = .finished
|
||||
|
||||
return .none
|
||||
return .none
|
||||
|
||||
case .waitingForDemand(let task, let upstreams):
|
||||
// The downstream task got cancelled so we need to cancel our upstream Task
|
||||
@@ -471,7 +489,8 @@ struct ZipStateMachine<
|
||||
|
||||
return .cancelTaskAndUpstreamContinuations(
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .zipping(let task, let upstreams, let downstreamContinuation):
|
||||
@@ -482,7 +501,8 @@ struct ZipStateMachine<
|
||||
return .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
|
||||
downstreamContinuation: downstreamContinuation,
|
||||
task: task,
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
upstreamContinuations: [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
)
|
||||
|
||||
case .finished:
|
||||
@@ -524,7 +544,8 @@ struct ZipStateMachine<
|
||||
// We also need to resume all upstream continuations now
|
||||
self.state = .modifying
|
||||
|
||||
let upstreamContinuations = [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation].compactMap { $0 }
|
||||
let upstreamContinuations = [upstreams.0.continuation, upstreams.1.continuation, upstreams.2.continuation]
|
||||
.compactMap { $0 }
|
||||
upstreams.0.continuation = nil
|
||||
upstreams.1.continuation = nil
|
||||
upstreams.2.continuation = nil
|
||||
|
||||
@@ -9,8 +9,16 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: Sendable
|
||||
where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable, Base3: Sendable, Base3.Element: Sendable {
|
||||
where
|
||||
Base1: Sendable,
|
||||
Base1.Element: Sendable,
|
||||
Base2: Sendable,
|
||||
Base2.Element: Sendable,
|
||||
Base3: Sendable,
|
||||
Base3.Element: Sendable
|
||||
{
|
||||
typealias StateMachine = ZipStateMachine<Base1, Base2, Base3>
|
||||
|
||||
private let stateMachine: ManagedCriticalState<StateMachine>
|
||||
@@ -63,9 +71,9 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
|
||||
switch action {
|
||||
case .startTask:
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
// We are handling the startTask in the lock already because we want to avoid
|
||||
// other inputs interleaving while starting the task
|
||||
fatalError("Internal inconsistency")
|
||||
|
||||
case .resumeUpstreamContinuations(let upstreamContinuations):
|
||||
// bases can be iterated over for 1 iteration so their next value can be retrieved
|
||||
@@ -76,7 +84,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
continuation.resume(returning: .success(nil))
|
||||
|
||||
case .none:
|
||||
break
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
@@ -304,30 +312,30 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
}
|
||||
|
||||
while !group.isEmpty {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
do {
|
||||
try await group.next()
|
||||
} catch {
|
||||
// One of the upstream sequences threw an error
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.upstreamThrew(error)
|
||||
}
|
||||
switch action {
|
||||
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
|
||||
let downstreamContinuation,
|
||||
let error,
|
||||
let task,
|
||||
let upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .failure(error))
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
group.cancelAll()
|
||||
let action = self.stateMachine.withCriticalRegion { stateMachine in
|
||||
stateMachine.upstreamThrew(error)
|
||||
}
|
||||
switch action {
|
||||
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
|
||||
let downstreamContinuation,
|
||||
let error,
|
||||
let task,
|
||||
let upstreamContinuations
|
||||
):
|
||||
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
|
||||
task.cancel()
|
||||
|
||||
downstreamContinuation.resume(returning: .failure(error))
|
||||
case .none:
|
||||
break
|
||||
}
|
||||
|
||||
group.cancelAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,16 +15,32 @@ import AsyncSequenceValidation
|
||||
|
||||
extension XCTestCase {
|
||||
func recordFailure(_ description: String, system: Bool = false, at location: AsyncSequenceValidation.SourceLocation) {
|
||||
#if canImport(Darwin)
|
||||
let context = XCTSourceCodeContext(location: XCTSourceCodeLocation(filePath: location.file.description, lineNumber: Int(location.line)))
|
||||
let issue = XCTIssue(type: system ? .system : .assertionFailure, compactDescription: description, detailedDescription: nil, sourceCodeContext: context, associatedError: nil, attachments: [])
|
||||
#if canImport(Darwin)
|
||||
let context = XCTSourceCodeContext(
|
||||
location: XCTSourceCodeLocation(filePath: location.file.description, lineNumber: Int(location.line))
|
||||
)
|
||||
let issue = XCTIssue(
|
||||
type: system ? .system : .assertionFailure,
|
||||
compactDescription: description,
|
||||
detailedDescription: nil,
|
||||
sourceCodeContext: context,
|
||||
associatedError: nil,
|
||||
attachments: []
|
||||
)
|
||||
record(issue)
|
||||
#else
|
||||
#else
|
||||
XCTFail(description, file: location.file, line: location.line)
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(theme: Theme, expectedFailures: Set<String>, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(
|
||||
theme: Theme,
|
||||
expectedFailures: Set<String>,
|
||||
@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) {
|
||||
var expectations = expectedFailures
|
||||
var result: AsyncSequenceValidationDiagram.ExpectationResult?
|
||||
var failures = [AsyncSequenceValidationDiagram.ExpectationFailure]()
|
||||
@@ -61,16 +77,33 @@ extension XCTestCase {
|
||||
XCTFail("Expected failure: \(expectation) did not occur.", file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
func validate<Test: AsyncSequenceValidationTest>(expectedFailures: Set<String>, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
func validate<Test: AsyncSequenceValidationTest>(
|
||||
expectedFailures: Set<String>,
|
||||
@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) {
|
||||
validate(theme: .ascii, expectedFailures: expectedFailures, build, file: file, line: line)
|
||||
}
|
||||
|
||||
public func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(theme: Theme, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(
|
||||
theme: Theme,
|
||||
@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) {
|
||||
validate(theme: theme, expectedFailures: [], build, file: file, line: line)
|
||||
}
|
||||
|
||||
public func validate<Test: AsyncSequenceValidationTest>(@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public func validate<Test: AsyncSequenceValidationTest>(
|
||||
@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) {
|
||||
validate(theme: .ascii, expectedFailures: [], build, file: file, line: line)
|
||||
}
|
||||
}
|
||||
@@ -12,71 +12,115 @@
|
||||
import _CAsyncSequenceValidationSupport
|
||||
|
||||
@resultBuilder
|
||||
public struct AsyncSequenceValidationDiagram : Sendable {
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public struct AsyncSequenceValidationDiagram: Sendable {
|
||||
public struct Component<T> {
|
||||
var component: T
|
||||
var location: SourceLocation
|
||||
}
|
||||
|
||||
|
||||
public struct AccumulatedInputs {
|
||||
var inputs: [Specification] = []
|
||||
}
|
||||
|
||||
|
||||
public struct AccumulatedInputsWithOperation<Operation: AsyncSequence> where Operation.Element == String {
|
||||
var inputs: [Specification]
|
||||
var operation: Operation
|
||||
}
|
||||
|
||||
public static func buildExpression(_ expr: String, file: StaticString = #file, line: UInt = #line) -> Component<String> {
|
||||
|
||||
public static func buildExpression(
|
||||
_ expr: String,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) -> Component<String> {
|
||||
Component(component: expr, location: SourceLocation(file: file, line: line))
|
||||
}
|
||||
|
||||
public static func buildExpression<S: AsyncSequence>(_ expr: S, file: StaticString = #file, line: UInt = #line) -> Component<S> {
|
||||
|
||||
public static func buildExpression<S: AsyncSequence>(
|
||||
_ expr: S,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) -> Component<S> {
|
||||
Component(component: expr, location: SourceLocation(file: file, line: line))
|
||||
}
|
||||
|
||||
|
||||
public static func buildPartialBlock(first input: Component<String>) -> AccumulatedInputs {
|
||||
return AccumulatedInputs(inputs: [Specification(specification: input.component, location: input.location)])
|
||||
}
|
||||
|
||||
public static func buildPartialBlock<Operation: AsyncSequence>(first operation: Component<Operation>) -> AccumulatedInputsWithOperation<Operation> where Operation.Element == String {
|
||||
|
||||
public static func buildPartialBlock<Operation: AsyncSequence>(
|
||||
first operation: Component<Operation>
|
||||
) -> AccumulatedInputsWithOperation<Operation> where Operation.Element == String {
|
||||
return AccumulatedInputsWithOperation(inputs: [], operation: operation.component)
|
||||
}
|
||||
|
||||
public static func buildPartialBlock(accumulated: AccumulatedInputs, next input: Component<String>) -> AccumulatedInputs {
|
||||
return AccumulatedInputs(inputs: accumulated.inputs + [Specification(specification: input.component, location: input.location)])
|
||||
|
||||
public static func buildPartialBlock(
|
||||
accumulated: AccumulatedInputs,
|
||||
next input: Component<String>
|
||||
) -> AccumulatedInputs {
|
||||
return AccumulatedInputs(
|
||||
inputs: accumulated.inputs + [Specification(specification: input.component, location: input.location)]
|
||||
)
|
||||
}
|
||||
|
||||
public static func buildPartialBlock<Operation: AsyncSequence>(accumulated: AccumulatedInputs, next operation: Component<Operation>) -> AccumulatedInputsWithOperation<Operation> {
|
||||
|
||||
public static func buildPartialBlock<Operation: AsyncSequence>(
|
||||
accumulated: AccumulatedInputs,
|
||||
next operation: Component<Operation>
|
||||
) -> AccumulatedInputsWithOperation<Operation> {
|
||||
return AccumulatedInputsWithOperation(inputs: accumulated.inputs, operation: operation.component)
|
||||
}
|
||||
|
||||
public static func buildPartialBlock<Operation: AsyncSequence>(accumulated: AccumulatedInputsWithOperation<Operation>, next output: Component<String>) -> some AsyncSequenceValidationTest {
|
||||
return Test(inputs: accumulated.inputs, sequence: accumulated.operation, output: Specification(specification: output.component, location: output.location))
|
||||
|
||||
public static func buildPartialBlock<Operation: AsyncSequence>(
|
||||
accumulated: AccumulatedInputsWithOperation<Operation>,
|
||||
next output: Component<String>
|
||||
) -> some AsyncSequenceValidationTest {
|
||||
return Test(
|
||||
inputs: accumulated.inputs,
|
||||
sequence: accumulated.operation,
|
||||
output: Specification(specification: output.component, location: output.location)
|
||||
)
|
||||
}
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(_ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(
|
||||
_ sequence: Component<Operation>,
|
||||
_ output: Component<String>
|
||||
) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
let part1 = buildPartialBlock(first: sequence)
|
||||
let part2 = buildPartialBlock(accumulated: part1, next: output)
|
||||
return part2
|
||||
}
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(
|
||||
_ input1: Component<String>,
|
||||
_ sequence: Component<Operation>,
|
||||
_ output: Component<String>
|
||||
) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
let part1 = buildPartialBlock(first: input1)
|
||||
let part2 = buildPartialBlock(accumulated: part1, next: sequence)
|
||||
let part3 = buildPartialBlock(accumulated: part2, next: output)
|
||||
return part3
|
||||
}
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ input2: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(
|
||||
_ input1: Component<String>,
|
||||
_ input2: Component<String>,
|
||||
_ sequence: Component<Operation>,
|
||||
_ output: Component<String>
|
||||
) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
let part1 = buildPartialBlock(first: input1)
|
||||
let part2 = buildPartialBlock(accumulated: part1, next: input2)
|
||||
let part3 = buildPartialBlock(accumulated: part2, next: sequence)
|
||||
let part4 = buildPartialBlock(accumulated: part3, next: output)
|
||||
return part4
|
||||
}
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ input2: Component<String>, _ input3: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(
|
||||
_ input1: Component<String>,
|
||||
_ input2: Component<String>,
|
||||
_ input3: Component<String>,
|
||||
_ sequence: Component<Operation>,
|
||||
_ output: Component<String>
|
||||
) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
let part1 = buildPartialBlock(first: input1)
|
||||
let part2 = buildPartialBlock(accumulated: part1, next: input2)
|
||||
let part3 = buildPartialBlock(accumulated: part2, next: input3)
|
||||
@@ -84,8 +128,15 @@ public struct AsyncSequenceValidationDiagram : Sendable {
|
||||
let part5 = buildPartialBlock(accumulated: part4, next: output)
|
||||
return part5
|
||||
}
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ input2: Component<String>, _ input3: Component<String>, _ input4: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
|
||||
public static func buildBlock<Operation: AsyncSequence>(
|
||||
_ input1: Component<String>,
|
||||
_ input2: Component<String>,
|
||||
_ input3: Component<String>,
|
||||
_ input4: Component<String>,
|
||||
_ sequence: Component<Operation>,
|
||||
_ output: Component<String>
|
||||
) -> some AsyncSequenceValidationTest where Operation.Element == String {
|
||||
let part1 = buildPartialBlock(first: input1)
|
||||
let part2 = buildPartialBlock(accumulated: part1, next: input2)
|
||||
let part3 = buildPartialBlock(accumulated: part2, next: input3)
|
||||
@@ -94,17 +145,17 @@ public struct AsyncSequenceValidationDiagram : Sendable {
|
||||
let part6 = buildPartialBlock(accumulated: part5, next: output)
|
||||
return part6
|
||||
}
|
||||
|
||||
|
||||
let queue: WorkQueue
|
||||
let _clock: Clock
|
||||
|
||||
|
||||
public var inputs: InputList
|
||||
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
public var clock: Clock {
|
||||
_clock
|
||||
}
|
||||
|
||||
|
||||
internal init() {
|
||||
let queue = WorkQueue()
|
||||
self.queue = queue
|
||||
@@ -112,4 +163,3 @@ public struct AsyncSequenceValidationDiagram : Sendable {
|
||||
self._clock = Clock(queue: queue)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,22 +11,22 @@
|
||||
|
||||
import AsyncAlgorithms
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram {
|
||||
public struct Clock {
|
||||
let queue: WorkQueue
|
||||
|
||||
|
||||
init(queue: WorkQueue) {
|
||||
self.queue = queue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public protocol TestClock: Sendable {
|
||||
associatedtype Instant: TestInstant
|
||||
|
||||
|
||||
var now: Instant { get }
|
||||
|
||||
|
||||
func sleep(until deadline: Self.Instant, tolerance: Self.Instant.Duration?) async throws
|
||||
}
|
||||
|
||||
@@ -34,80 +34,81 @@ public protocol TestInstant: Equatable {
|
||||
associatedtype Duration
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock {
|
||||
public struct Step: DurationProtocol, Hashable, CustomStringConvertible {
|
||||
internal var rawValue: Int
|
||||
|
||||
|
||||
internal init(_ rawValue: Int) {
|
||||
self.rawValue = rawValue
|
||||
}
|
||||
|
||||
|
||||
public static func + (lhs: Step, rhs: Step) -> Step {
|
||||
return .init(lhs.rawValue + rhs.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public static func - (lhs: Step, rhs: Step) -> Step {
|
||||
.init(lhs.rawValue - rhs.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public static func / (lhs: Step, rhs: Int) -> Step {
|
||||
.init(lhs.rawValue / rhs)
|
||||
}
|
||||
|
||||
|
||||
public static func * (lhs: Step, rhs: Int) -> Step {
|
||||
.init(lhs.rawValue * rhs)
|
||||
}
|
||||
|
||||
|
||||
public static func / (lhs: Step, rhs: Step) -> Double {
|
||||
Double(lhs.rawValue) / Double(rhs.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public static func < (lhs: Step, rhs: Step) -> Bool {
|
||||
lhs.rawValue < rhs.rawValue
|
||||
}
|
||||
|
||||
|
||||
public static var zero: Step { .init(0) }
|
||||
|
||||
|
||||
public static func steps(_ amount: Int) -> Step {
|
||||
return Step(amount)
|
||||
}
|
||||
|
||||
|
||||
public var description: String {
|
||||
return "step \(rawValue)"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public struct Instant: CustomStringConvertible {
|
||||
public typealias Duration = Step
|
||||
|
||||
|
||||
let when: Step
|
||||
|
||||
|
||||
public func advanced(by duration: Step) -> Instant {
|
||||
Instant(when: when + duration)
|
||||
}
|
||||
|
||||
|
||||
public func duration(to other: Instant) -> Step {
|
||||
other.when - when
|
||||
}
|
||||
|
||||
|
||||
public static func < (lhs: Instant, rhs: Instant) -> Bool {
|
||||
lhs.when < rhs.when
|
||||
}
|
||||
|
||||
|
||||
public var description: String {
|
||||
// the raw value is 1 indexed in execution but we should report it as 0 indexed
|
||||
return "tick \(when.rawValue - 1)"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public var now: Instant {
|
||||
queue.now
|
||||
}
|
||||
|
||||
|
||||
public var minimumResolution: Step {
|
||||
.steps(1)
|
||||
}
|
||||
|
||||
|
||||
public func sleep(
|
||||
until deadline: Instant,
|
||||
tolerance: Step? = nil
|
||||
@@ -115,7 +116,12 @@ extension AsyncSequenceValidationDiagram.Clock {
|
||||
let token = queue.prepare()
|
||||
try await withTaskCancellationHandler {
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
queue.enqueue(AsyncSequenceValidationDiagram.Context.currentJob, deadline: deadline, continuation: continuation, token: token)
|
||||
queue.enqueue(
|
||||
AsyncSequenceValidationDiagram.Context.currentJob,
|
||||
deadline: deadline,
|
||||
continuation: continuation,
|
||||
token: token
|
||||
)
|
||||
}
|
||||
} onCancel: {
|
||||
queue.cancel(token)
|
||||
@@ -123,16 +129,20 @@ extension AsyncSequenceValidationDiagram.Clock {
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: TestInstant { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: TestInstant {}
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: InstantProtocol { }
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: InstantProtocol {}
|
||||
|
||||
extension AsyncSequenceValidationDiagram.Clock: TestClock { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock: TestClock {}
|
||||
|
||||
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock: Clock { }
|
||||
extension AsyncSequenceValidationDiagram.Clock: Clock {}
|
||||
|
||||
// placeholders to avoid warnings
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: Hashable { }
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: Comparable { }
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: Hashable {}
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram.Clock.Instant: Comparable {}
|
||||
@@ -9,14 +9,15 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram {
|
||||
struct Failure: Error, Equatable { }
|
||||
|
||||
struct Failure: Error, Equatable {}
|
||||
|
||||
enum ParseFailure: Error, CustomStringConvertible, SourceFailure {
|
||||
case stepInGroup(String, String.Index, SourceLocation)
|
||||
case nestedGroup(String, String.Index, SourceLocation)
|
||||
case unbalancedNesting(String, String.Index, SourceLocation)
|
||||
|
||||
|
||||
var location: SourceLocation {
|
||||
switch self {
|
||||
case .stepInGroup(_, _, let location): return location
|
||||
@@ -24,7 +25,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
case .unbalancedNesting(_, _, let location): return location
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .stepInGroup:
|
||||
@@ -36,14 +37,14 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
enum Event {
|
||||
case value(String, String.Index)
|
||||
case failure(Error, String.Index)
|
||||
case finish(String.Index)
|
||||
case delayNext(String.Index)
|
||||
case cancel(String.Index)
|
||||
|
||||
|
||||
var results: [Result<String?, Error>] {
|
||||
switch self {
|
||||
case .value(let value, _): return [.success(value)]
|
||||
@@ -53,7 +54,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
case .cancel: return []
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var index: String.Index {
|
||||
switch self {
|
||||
case .value(_, let index): return index
|
||||
@@ -63,23 +64,26 @@ extension AsyncSequenceValidationDiagram {
|
||||
case .cancel(let index): return index
|
||||
}
|
||||
}
|
||||
|
||||
static func parse<Theme: AsyncSequenceValidationTheme>(_ dsl: String, theme: Theme, location: SourceLocation) throws -> [(Clock.Instant, Event)] {
|
||||
|
||||
static func parse<Theme: AsyncSequenceValidationTheme>(
|
||||
_ dsl: String,
|
||||
theme: Theme,
|
||||
location: SourceLocation
|
||||
) throws -> [(Clock.Instant, Event)] {
|
||||
var emissions = [(Clock.Instant, Event)]()
|
||||
var when = Clock.Instant(when: .steps(0))
|
||||
var string: String?
|
||||
var grouping = 0
|
||||
|
||||
|
||||
for index in dsl.indices {
|
||||
let ch = dsl[index]
|
||||
switch theme.token(dsl[index], inValue: string != nil) {
|
||||
case .step:
|
||||
if string == nil {
|
||||
if grouping == 0 {
|
||||
when = when.advanced(by: .steps(1))
|
||||
} else {
|
||||
guard grouping == 0 else {
|
||||
throw ParseFailure.stepInGroup(dsl, index, location)
|
||||
}
|
||||
when = when.advanced(by: .steps(1))
|
||||
} else {
|
||||
string?.append(ch)
|
||||
}
|
||||
@@ -130,11 +134,10 @@ extension AsyncSequenceValidationDiagram {
|
||||
emissions.append((when, .value(value, index)))
|
||||
}
|
||||
case .beginGroup:
|
||||
if grouping == 0 {
|
||||
when = when.advanced(by: .steps(1))
|
||||
} else {
|
||||
guard grouping == 0 else {
|
||||
throw ParseFailure.nestedGroup(dsl, index, location)
|
||||
}
|
||||
when = when.advanced(by: .steps(1))
|
||||
grouping += 1
|
||||
case .endGroup:
|
||||
grouping -= 1
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram {
|
||||
public struct ExpectationResult: Sendable {
|
||||
public struct Event: Sendable {
|
||||
@@ -18,7 +19,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
public var expected: [Event]
|
||||
public var actual: [(Clock.Instant, Result<String?, Error>)]
|
||||
|
||||
|
||||
func reconstitute<Theme: AsyncSequenceValidationTheme>(_ result: Result<String?, Error>, theme: Theme) -> String {
|
||||
var reconstituted = ""
|
||||
switch result {
|
||||
@@ -39,9 +40,13 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
return reconstituted
|
||||
}
|
||||
|
||||
func reconstitute<Theme: AsyncSequenceValidationTheme>(_ events: [Clock.Instant : [Result<String?, Error>]], theme: Theme, end: Clock.Instant) -> String {
|
||||
var now = Clock.Instant(when: .steps(1)) // adjust for the offset index
|
||||
|
||||
func reconstitute<Theme: AsyncSequenceValidationTheme>(
|
||||
_ events: [Clock.Instant: [Result<String?, Error>]],
|
||||
theme: Theme,
|
||||
end: Clock.Instant
|
||||
) -> String {
|
||||
var now = Clock.Instant(when: .steps(1)) // adjust for the offset index
|
||||
var reconstituted = ""
|
||||
while now <= end {
|
||||
if let results = events[now] {
|
||||
@@ -61,11 +66,11 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
return reconstituted
|
||||
}
|
||||
|
||||
|
||||
public func reconstituteExpected<Theme: AsyncSequenceValidationTheme>(theme: Theme) -> String {
|
||||
var events = [Clock.Instant : [Result<String?, Error>]]()
|
||||
var events = [Clock.Instant: [Result<String?, Error>]]()
|
||||
var end: Clock.Instant = Clock.Instant(when: .zero)
|
||||
|
||||
|
||||
for expectation in expected {
|
||||
let when = expectation.when
|
||||
let result = expectation.result
|
||||
@@ -74,25 +79,25 @@ extension AsyncSequenceValidationDiagram {
|
||||
end = when
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return reconstitute(events, theme: theme, end: end)
|
||||
}
|
||||
|
||||
|
||||
public func reconstituteActual<Theme: AsyncSequenceValidationTheme>(theme: Theme) -> String {
|
||||
var events = [Clock.Instant : [Result<String?, Error>]]()
|
||||
var events = [Clock.Instant: [Result<String?, Error>]]()
|
||||
var end: Clock.Instant = Clock.Instant(when: .zero)
|
||||
|
||||
|
||||
for (when, result) in actual {
|
||||
events[when, default: []].append(result)
|
||||
if when > end {
|
||||
end = when
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return reconstitute(events, theme: theme, end: end)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public struct ExpectationFailure: Sendable, CustomStringConvertible {
|
||||
public enum Kind: Sendable {
|
||||
case expectedFinishButGotValue(String)
|
||||
@@ -108,23 +113,23 @@ extension AsyncSequenceValidationDiagram {
|
||||
case unexpectedValue(String)
|
||||
case unexpectedFinish
|
||||
case unexpectedFailure(Error)
|
||||
|
||||
|
||||
case specificationViolationGotValueAfterIteration(String)
|
||||
case specificationViolationGotFailureAfterIteration(Error)
|
||||
}
|
||||
public var when: Clock.Instant
|
||||
public var kind: Kind
|
||||
|
||||
|
||||
public var specification: Specification?
|
||||
public var index: String.Index?
|
||||
|
||||
|
||||
init(when: Clock.Instant, kind: Kind, specification: Specification? = nil, index: String.Index? = nil) {
|
||||
self.when = when
|
||||
self.kind = kind
|
||||
self.specification = specification
|
||||
self.index = index
|
||||
}
|
||||
|
||||
|
||||
var reason: String {
|
||||
switch kind {
|
||||
case .expectedFinishButGotValue(let actual):
|
||||
@@ -159,7 +164,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
return "specification violation got failure after iteration terminated"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public var description: String {
|
||||
return reason + " at tick \(when.when.rawValue - 1)"
|
||||
}
|
||||
|
||||
@@ -9,35 +9,36 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram {
|
||||
public struct Specification: Sendable {
|
||||
public let specification: String
|
||||
public let location: SourceLocation
|
||||
|
||||
|
||||
init(specification: String, location: SourceLocation) {
|
||||
self.specification = specification
|
||||
self.location = location
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public struct Input: AsyncSequence, Sendable {
|
||||
public typealias Element = String
|
||||
|
||||
|
||||
struct State {
|
||||
var emissions = [(Clock.Instant, Event)]()
|
||||
}
|
||||
|
||||
|
||||
let state = ManagedCriticalState(State())
|
||||
let queue: WorkQueue
|
||||
let index: Int
|
||||
|
||||
|
||||
public struct Iterator: AsyncIteratorProtocol, Sendable {
|
||||
let state: ManagedCriticalState<State>
|
||||
let queue: WorkQueue
|
||||
let index: Int
|
||||
var active: (Clock.Instant, [Result<String?, Error>])?
|
||||
var eventIndex = 0
|
||||
|
||||
|
||||
mutating func apply(when: Clock.Instant, results: [Result<String?, Error>]) async throws -> Element? {
|
||||
let token = queue.prepare()
|
||||
if eventIndex + 1 >= results.count {
|
||||
@@ -52,17 +53,22 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
return try await withTaskCancellationHandler {
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
queue.enqueue(Context.currentJob, deadline: when, continuation: continuation, results[eventIndex], index: index, token: token)
|
||||
queue.enqueue(
|
||||
Context.currentJob,
|
||||
deadline: when,
|
||||
continuation: continuation,
|
||||
results[eventIndex],
|
||||
index: index,
|
||||
token: token
|
||||
)
|
||||
}
|
||||
} onCancel: { [queue] in
|
||||
queue.cancel(token)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public mutating func next() async throws -> Element? {
|
||||
if let (when, results) = active {
|
||||
return try await apply(when: when, results: results)
|
||||
} else {
|
||||
guard let (when, results) = active else {
|
||||
let next = state.withCriticalRegion { state -> (Clock.Instant, Event)? in
|
||||
guard state.emissions.count > 0 else {
|
||||
return nil
|
||||
@@ -77,36 +83,37 @@ extension AsyncSequenceValidationDiagram {
|
||||
active = (when, results)
|
||||
return try await apply(when: when, results: results)
|
||||
}
|
||||
return try await apply(when: when, results: results)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(state: state, queue: queue, index: index)
|
||||
}
|
||||
|
||||
|
||||
func parse<Theme: AsyncSequenceValidationTheme>(_ dsl: String, theme: Theme, location: SourceLocation) throws {
|
||||
let emissions = try Event.parse(dsl, theme: theme, location: location)
|
||||
state.withCriticalRegion { state in
|
||||
state.emissions = emissions
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var end: Clock.Instant? {
|
||||
return state.withCriticalRegion { state in
|
||||
state.emissions.map { $0.0 }.sorted().last
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public struct InputList: RandomAccessCollection, Sendable {
|
||||
let state = ManagedCriticalState([Input]())
|
||||
let queue: WorkQueue
|
||||
|
||||
|
||||
public var startIndex: Int { return 0 }
|
||||
public var endIndex: Int {
|
||||
state.withCriticalRegion { $0.count }
|
||||
}
|
||||
|
||||
|
||||
public subscript(position: Int) -> AsyncSequenceValidationDiagram.Input {
|
||||
get {
|
||||
return state.withCriticalRegion { state in
|
||||
|
||||
@@ -11,13 +11,14 @@
|
||||
|
||||
import _CAsyncSequenceValidationSupport
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct Job: Hashable, @unchecked Sendable {
|
||||
let job: JobRef
|
||||
|
||||
|
||||
init(_ job: JobRef) {
|
||||
self.job = job
|
||||
}
|
||||
|
||||
|
||||
func execute() {
|
||||
_swiftJobRun(unsafeBitCast(job, to: UnownedJob.self), AsyncSequenceValidationDiagram.Context.unownedExecutor)
|
||||
}
|
||||
|
||||
@@ -12,12 +12,12 @@
|
||||
public struct SourceLocation: Sendable, CustomStringConvertible {
|
||||
public var file: StaticString
|
||||
public var line: UInt
|
||||
|
||||
|
||||
public init(file: StaticString, line: UInt) {
|
||||
self.file = file
|
||||
self.line = line
|
||||
}
|
||||
|
||||
|
||||
public var description: String {
|
||||
return "\(file):\(line)"
|
||||
}
|
||||
|
||||
@@ -26,16 +26,19 @@ import Bionic
|
||||
#endif
|
||||
|
||||
#if canImport(Darwin)
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer? {
|
||||
Unmanaged<TaskDriver>.fromOpaque(raw).takeRetainedValue().run()
|
||||
return nil
|
||||
}
|
||||
#elseif (canImport(Glibc) && !os(Android)) || canImport(Musl)
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
func start_thread(_ raw: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
|
||||
Unmanaged<TaskDriver>.fromOpaque(raw!).takeRetainedValue().run()
|
||||
return nil
|
||||
}
|
||||
#elseif os(Android)
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer {
|
||||
Unmanaged<TaskDriver>.fromOpaque(raw).takeRetainedValue().run()
|
||||
return UnsafeMutableRawPointer(bitPattern: 0xdeadbee)!
|
||||
@@ -44,48 +47,53 @@ func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer {
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
final class TaskDriver {
|
||||
let work: (TaskDriver) -> Void
|
||||
let queue: WorkQueue
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
var thread: pthread_t?
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
var thread = pthread_t()
|
||||
#elseif canImport(WinSDK)
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
|
||||
#elseif canImport(WinSDK)
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
|
||||
init(queue: WorkQueue, _ work: @escaping (TaskDriver) -> Void) {
|
||||
self.queue = queue
|
||||
self.work = work
|
||||
}
|
||||
|
||||
|
||||
func start() {
|
||||
#if canImport(Darwin) || canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
pthread_create(&thread, nil, start_thread,
|
||||
Unmanaged.passRetained(self).toOpaque())
|
||||
#elseif canImport(WinSDK)
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
#if canImport(Darwin) || canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
pthread_create(
|
||||
&thread,
|
||||
nil,
|
||||
start_thread,
|
||||
Unmanaged.passRetained(self).toOpaque()
|
||||
)
|
||||
#elseif canImport(WinSDK)
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
func run() {
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
pthread_setname_np("Validation Diagram Clock Driver")
|
||||
#endif
|
||||
#endif
|
||||
work(self)
|
||||
}
|
||||
|
||||
|
||||
func join() {
|
||||
#if canImport(Darwin)
|
||||
#if canImport(Darwin)
|
||||
pthread_join(thread!, nil)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
|
||||
pthread_join(thread, nil)
|
||||
#elseif canImport(WinSDK)
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
#elseif canImport(WinSDK)
|
||||
#error("TODO: Port TaskDriver threading to windows")
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
func enqueue(_ job: JobRef) {
|
||||
let job = Job(job)
|
||||
queue.enqueue(AsyncSequenceValidationDiagram.Context.currentJob) {
|
||||
@@ -96,4 +104,3 @@ final class TaskDriver {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,51 +13,66 @@ import _CAsyncSequenceValidationSupport
|
||||
import AsyncAlgorithms
|
||||
|
||||
@_silgen_name("swift_job_run")
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
@usableFromInline
|
||||
internal func _swiftJobRun(
|
||||
_ job: UnownedJob,
|
||||
_ executor: UnownedSerialExecutor
|
||||
) -> ()
|
||||
)
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public protocol AsyncSequenceValidationTest: Sendable {
|
||||
var inputs: [AsyncSequenceValidationDiagram.Specification] { get }
|
||||
var output: AsyncSequenceValidationDiagram.Specification { get }
|
||||
|
||||
func test<C: TestClock>(with clock: C, activeTicks: [C.Instant], output: AsyncSequenceValidationDiagram.Specification, _ event: (String) -> Void) async throws
|
||||
|
||||
func test<C: TestClock>(
|
||||
with clock: C,
|
||||
activeTicks: [C.Instant],
|
||||
output: AsyncSequenceValidationDiagram.Specification,
|
||||
_ event: (String) -> Void
|
||||
) async throws
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram {
|
||||
struct Test<Operation: AsyncSequence>: AsyncSequenceValidationTest, @unchecked Sendable where Operation.Element == String {
|
||||
struct Test<Operation: AsyncSequence>: AsyncSequenceValidationTest, @unchecked Sendable
|
||||
where Operation.Element == String {
|
||||
let inputs: [Specification]
|
||||
let sequence: Operation
|
||||
let output: Specification
|
||||
|
||||
func test<C: TestClock>(with clock: C, activeTicks: [C.Instant], output: Specification, _ event: (String) -> Void) async throws {
|
||||
|
||||
func test<C: TestClock>(
|
||||
with clock: C,
|
||||
activeTicks: [C.Instant],
|
||||
output: Specification,
|
||||
_ event: (String) -> Void
|
||||
) async throws {
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
for tick in activeTicks {
|
||||
if tick != clock.now {
|
||||
try await clock.sleep(until: tick, tolerance: nil)
|
||||
}
|
||||
if let item = try await iterator.next() {
|
||||
event(item)
|
||||
} else {
|
||||
guard let item = try await iterator.next() else {
|
||||
break
|
||||
}
|
||||
event(item)
|
||||
}
|
||||
do {
|
||||
if let pastEnd = try await iterator.next(){
|
||||
if let pastEnd = try await iterator.next() {
|
||||
let failure = ExpectationFailure(
|
||||
when: Context.clock!.now,
|
||||
kind: .specificationViolationGotValueAfterIteration(pastEnd),
|
||||
specification: output)
|
||||
specification: output
|
||||
)
|
||||
Context.specificationFailures.append(failure)
|
||||
}
|
||||
} catch {
|
||||
let failure = ExpectationFailure(
|
||||
when: Context.clock!.now,
|
||||
kind: .specificationViolationGotFailureAfterIteration(error),
|
||||
specification: output)
|
||||
specification: output
|
||||
)
|
||||
Context.specificationFailures.append(failure)
|
||||
}
|
||||
} catch {
|
||||
@@ -65,9 +80,9 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct Context {
|
||||
#if swift(<5.9)
|
||||
#if swift(<5.9)
|
||||
final class ClockExecutor: SerialExecutor {
|
||||
func enqueue(_ job: UnownedJob) {
|
||||
job._runSynchronously(on: self.asUnownedSerialExecutor())
|
||||
@@ -77,24 +92,24 @@ extension AsyncSequenceValidationDiagram {
|
||||
UnownedSerialExecutor(ordinary: self)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private static let _executor = ClockExecutor()
|
||||
|
||||
|
||||
static var unownedExecutor: UnownedSerialExecutor {
|
||||
_executor.asUnownedSerialExecutor()
|
||||
}
|
||||
#else
|
||||
#else
|
||||
@available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *)
|
||||
final class ClockExecutor_5_9: SerialExecutor {
|
||||
final class ClockExecutor_5_9: SerialExecutor {
|
||||
func enqueue(_ job: __owned ExecutorJob) {
|
||||
job.runSynchronously(on: asUnownedSerialExecutor())
|
||||
}
|
||||
|
||||
|
||||
func asUnownedSerialExecutor() -> UnownedSerialExecutor {
|
||||
UnownedSerialExecutor(ordinary: self)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
final class ClockExecutor_Pre5_9: SerialExecutor {
|
||||
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
|
||||
@available(*, deprecated, message: "Implement 'enqueue(_: __owned ExecutorJob)' instead")
|
||||
@@ -106,36 +121,33 @@ extension AsyncSequenceValidationDiagram {
|
||||
UnownedSerialExecutor(ordinary: self)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private static let _executor: AnyObject = {
|
||||
if #available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) {
|
||||
return ClockExecutor_5_9()
|
||||
} else {
|
||||
guard #available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) else {
|
||||
return ClockExecutor_Pre5_9()
|
||||
}
|
||||
return ClockExecutor_5_9()
|
||||
}()
|
||||
|
||||
|
||||
static var unownedExecutor: UnownedSerialExecutor {
|
||||
(_executor as! any SerialExecutor).asUnownedSerialExecutor()
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static var clock: Clock?
|
||||
|
||||
|
||||
|
||||
|
||||
static var driver: TaskDriver?
|
||||
|
||||
|
||||
static var currentJob: Job?
|
||||
|
||||
|
||||
static var specificationFailures = [ExpectationFailure]()
|
||||
}
|
||||
|
||||
|
||||
enum ActualResult {
|
||||
case success(String?)
|
||||
case failure(Error)
|
||||
case none
|
||||
|
||||
|
||||
init(_ result: Result<String?, Error>?) {
|
||||
if let result = result {
|
||||
switch result {
|
||||
@@ -149,7 +161,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static func validate<Theme: AsyncSequenceValidationTheme>(
|
||||
inputs: [Specification],
|
||||
output: Specification,
|
||||
@@ -160,21 +172,21 @@ extension AsyncSequenceValidationDiagram {
|
||||
let result = ExpectationResult(expected: expected, actual: actual)
|
||||
var failures = Context.specificationFailures
|
||||
Context.specificationFailures.removeAll()
|
||||
|
||||
|
||||
let actualTimes = actual.map { when, _ in when }
|
||||
let expectedTimes = expected.map { $0.when }
|
||||
|
||||
|
||||
var expectedMap = [Clock.Instant: [ExpectationResult.Event]]()
|
||||
var actualMap = [Clock.Instant: [Result<String?, Error>]]()
|
||||
|
||||
|
||||
for event in expected {
|
||||
expectedMap[event.when, default: []].append(event)
|
||||
}
|
||||
|
||||
|
||||
for (when, result) in actual {
|
||||
actualMap[when, default: []].append(result)
|
||||
}
|
||||
|
||||
|
||||
let allTimes = Set(actualTimes + expectedTimes).sorted()
|
||||
for when in allTimes {
|
||||
let expectedResults = expectedMap[when] ?? []
|
||||
@@ -192,21 +204,24 @@ extension AsyncSequenceValidationDiagram {
|
||||
when: when,
|
||||
kind: .expectedMismatch(expected, actual),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
case (.none, .some(let actual)):
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .expectedFinishButGotValue(actual),
|
||||
specification: output)
|
||||
specification: output
|
||||
)
|
||||
failures.append(failure)
|
||||
case (.some(let expected), .none):
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .expectedValueButGotFinished(expected),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
case (.none, .none):
|
||||
break
|
||||
@@ -217,14 +232,16 @@ extension AsyncSequenceValidationDiagram {
|
||||
when: when,
|
||||
kind: .expectedValueButGotFailure(expected, actual),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
} else {
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .expectedFinishButGotFailure(actual),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
case (.success(let expected), .none):
|
||||
@@ -234,14 +251,16 @@ extension AsyncSequenceValidationDiagram {
|
||||
when: when,
|
||||
kind: .expectedValue(expected),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
case .none:
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .expectedFinish,
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
case (.failure(let expected), .success(let actual)):
|
||||
@@ -250,14 +269,16 @@ extension AsyncSequenceValidationDiagram {
|
||||
when: when,
|
||||
kind: .expectedFailureButGotValue(expected, actual),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
} else {
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .expectedFailureButGotFinish(expected),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
case (.failure, .failure):
|
||||
@@ -267,7 +288,8 @@ extension AsyncSequenceValidationDiagram {
|
||||
when: when,
|
||||
kind: .expectedFailure(expected),
|
||||
specification: output,
|
||||
index: expectedEvent.offset)
|
||||
index: expectedEvent.offset
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
}
|
||||
@@ -279,28 +301,31 @@ extension AsyncSequenceValidationDiagram {
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .unexpectedValue(actual),
|
||||
specification: output)
|
||||
specification: output
|
||||
)
|
||||
failures.append(failure)
|
||||
case .none:
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .unexpectedFinish,
|
||||
specification: output)
|
||||
specification: output
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
case .failure(let actual):
|
||||
let failure = ExpectationFailure(
|
||||
when: when,
|
||||
kind: .unexpectedFailure(actual),
|
||||
specification: output)
|
||||
specification: output
|
||||
)
|
||||
failures.append(failure)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return (result, failures)
|
||||
}
|
||||
|
||||
|
||||
public static func test<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(
|
||||
theme: Theme,
|
||||
@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test
|
||||
@@ -312,30 +337,32 @@ extension AsyncSequenceValidationDiagram {
|
||||
// fault in all inputs
|
||||
_ = diagram.inputs[index]
|
||||
}
|
||||
|
||||
|
||||
for (index, input) in diagram.inputs.enumerated() {
|
||||
let inputSpecification = test.inputs[index]
|
||||
try input.parse(inputSpecification.specification, theme: theme, location: inputSpecification.location)
|
||||
}
|
||||
|
||||
|
||||
let parsedOutput = try Event.parse(test.output.specification, theme: theme, location: test.output.location)
|
||||
let cancelEvents = Set(parsedOutput.filter { when, event in
|
||||
switch event {
|
||||
case .cancel: return true
|
||||
default: return false
|
||||
}
|
||||
}.map { when, _ in return when })
|
||||
let cancelEvents = Set(
|
||||
parsedOutput.filter { when, event in
|
||||
switch event {
|
||||
case .cancel: return true
|
||||
default: return false
|
||||
}
|
||||
}.map { when, _ in return when }
|
||||
)
|
||||
|
||||
let activeTicks = parsedOutput.reduce(into: [Clock.Instant.init(when: .zero)]) { events, thisEvent in
|
||||
switch thisEvent {
|
||||
case (let when, .delayNext(_)):
|
||||
events.removeLast()
|
||||
events.append(when.advanced(by: .steps(1)))
|
||||
case (let when, _):
|
||||
events.append(when)
|
||||
case (let when, .delayNext(_)):
|
||||
events.removeLast()
|
||||
events.append(when.advanced(by: .steps(1)))
|
||||
case (let when, _):
|
||||
events.append(when)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var expected = [ExpectationResult.Event]()
|
||||
for (when, event) in parsedOutput {
|
||||
for result in event.results {
|
||||
@@ -343,7 +370,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
}
|
||||
let times = parsedOutput.map { when, _ in when }
|
||||
|
||||
|
||||
guard let end = (times + diagram.inputs.compactMap { $0.end }).max() else {
|
||||
return (ExpectationResult(expected: [], actual: []), [])
|
||||
}
|
||||
@@ -356,7 +383,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
swift_task_enqueueGlobal_hook = { job, original in
|
||||
Context.driver?.enqueue(job)
|
||||
}
|
||||
|
||||
|
||||
let runner = Task {
|
||||
do {
|
||||
try await test.test(with: clock, activeTicks: activeTicks, output: test.output) { event in
|
||||
@@ -373,7 +400,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Drain off any initial work. Work may spawn additional work to be done.
|
||||
// If the driver ever becomes blocked on the clock, exit early out of that
|
||||
// drain, because the drain cant make any forward progress if it is blocked
|
||||
@@ -387,7 +414,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
}
|
||||
diagram.queue.advance()
|
||||
}
|
||||
|
||||
|
||||
runner.cancel()
|
||||
Context.clock = nil
|
||||
swift_task_enqueueGlobal_hook = nil
|
||||
@@ -397,15 +424,16 @@ extension AsyncSequenceValidationDiagram {
|
||||
// else wise this would cause QoS inversions
|
||||
Context.driver?.join()
|
||||
Context.driver = nil
|
||||
|
||||
|
||||
return validate(
|
||||
inputs: test.inputs,
|
||||
output: test.output,
|
||||
theme: theme,
|
||||
expected: expected,
|
||||
actual: actual.withCriticalRegion { $0 })
|
||||
actual: actual.withCriticalRegion { $0 }
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
public static func test<Test: AsyncSequenceValidationTest>(
|
||||
@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test
|
||||
) throws -> (ExpectationResult, [ExpectationFailure]) {
|
||||
|
||||
@@ -9,18 +9,21 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
public protocol AsyncSequenceValidationTheme {
|
||||
func token(_ character: Character, inValue: Bool) -> AsyncSequenceValidationDiagram.Token
|
||||
|
||||
|
||||
func description(for token: AsyncSequenceValidationDiagram.Token) -> String
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationTheme where Self == AsyncSequenceValidationDiagram.ASCIITheme {
|
||||
public static var ascii: AsyncSequenceValidationDiagram.ASCIITheme {
|
||||
return AsyncSequenceValidationDiagram.ASCIITheme()
|
||||
}
|
||||
}
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
extension AsyncSequenceValidationDiagram {
|
||||
public enum Token: Sendable {
|
||||
case step
|
||||
@@ -35,7 +38,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
case skip
|
||||
case value(String)
|
||||
}
|
||||
|
||||
|
||||
public struct ASCIITheme: AsyncSequenceValidationTheme, Sendable {
|
||||
public func token(_ character: Character, inValue: Bool) -> AsyncSequenceValidationDiagram.Token {
|
||||
switch character {
|
||||
@@ -51,7 +54,7 @@ extension AsyncSequenceValidationDiagram {
|
||||
default: return .value(String(character))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func description(for token: AsyncSequenceValidationDiagram.Token) -> String {
|
||||
switch token {
|
||||
case .step: return "-"
|
||||
|
||||
@@ -9,13 +9,20 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(AsyncAlgorithms 1.0, *)
|
||||
struct WorkQueue: Sendable {
|
||||
enum Item: CustomStringConvertible, Comparable {
|
||||
case blocked(Token, AsyncSequenceValidationDiagram.Clock.Instant, UnsafeContinuation<Void, Error>)
|
||||
case emit(Token, AsyncSequenceValidationDiagram.Clock.Instant, UnsafeContinuation<String?, Error>, Result<String?, Error>, Int)
|
||||
case emit(
|
||||
Token,
|
||||
AsyncSequenceValidationDiagram.Clock.Instant,
|
||||
UnsafeContinuation<String?, Error>,
|
||||
Result<String?, Error>,
|
||||
Int
|
||||
)
|
||||
case work(Token, @Sendable () -> Void)
|
||||
case cancelled(Token)
|
||||
|
||||
|
||||
func run() {
|
||||
switch self {
|
||||
case .blocked(_, _, let continuation):
|
||||
@@ -28,7 +35,7 @@ struct WorkQueue: Sendable {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .blocked(let token, let when, _):
|
||||
@@ -41,7 +48,7 @@ struct WorkQueue: Sendable {
|
||||
return "cancelled #\(token)"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var token: Token {
|
||||
switch self {
|
||||
case .blocked(let token, _, _): return token
|
||||
@@ -50,14 +57,14 @@ struct WorkQueue: Sendable {
|
||||
case .cancelled(let token): return token
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var isCancelled: Bool {
|
||||
switch self {
|
||||
case .cancelled: return true
|
||||
default: return false
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func cancelling() -> Item {
|
||||
switch self {
|
||||
case .blocked(let token, _, let continuation):
|
||||
@@ -71,7 +78,7 @@ struct WorkQueue: Sendable {
|
||||
default: return self
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// the side order is repsected first since that is the logical flow of predictable events
|
||||
// then the generation is taken into account
|
||||
static func < (_ lhs: Item, _ rhs: Item) -> Bool {
|
||||
@@ -82,28 +89,28 @@ struct WorkQueue: Sendable {
|
||||
return lhs.token.generation < rhs.token.generation
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// all tokens are distinct so we know the generation of when it was enqueued
|
||||
// always means distinct equality (for ordering)
|
||||
static func == (_ lhs: Item, _ rhs: Item) -> Bool {
|
||||
return lhs.token == rhs.token
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct State {
|
||||
// the nil Job in these two structures represent the root job in the TaskDriver
|
||||
var queues = [Job? : [Item]]()
|
||||
var queues = [Job?: [Item]]()
|
||||
var jobs: [Job?] = [nil]
|
||||
var items = [Token : Item]()
|
||||
|
||||
var items = [Token: Item]()
|
||||
|
||||
var now = AsyncSequenceValidationDiagram.Clock.Instant(when: .zero)
|
||||
var generation = 0
|
||||
|
||||
|
||||
mutating func drain() -> [Item] {
|
||||
var items = [Item]()
|
||||
// store off the jobs such that we can only visit the active queues
|
||||
var jobs = self.jobs
|
||||
|
||||
|
||||
while true {
|
||||
let startingCount = items.count
|
||||
var jobsToRemove = Set<Int>()
|
||||
@@ -160,32 +167,32 @@ struct WorkQueue: Sendable {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return items
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
let state = ManagedCriticalState(State())
|
||||
|
||||
|
||||
var now: AsyncSequenceValidationDiagram.Clock.Instant {
|
||||
state.withCriticalRegion { $0.now }
|
||||
}
|
||||
|
||||
|
||||
struct Token: Hashable, CustomStringConvertible {
|
||||
var generation: Int
|
||||
|
||||
|
||||
var description: String {
|
||||
return generation.description
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func prepare() -> Token {
|
||||
state.withCriticalRegion { state in
|
||||
defer { state.generation += 1 }
|
||||
return Token(generation: state.generation)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func cancel(_ token: Token) {
|
||||
state.withCriticalRegion { state in
|
||||
if let existing = state.items[token] {
|
||||
@@ -212,16 +219,24 @@ struct WorkQueue: Sendable {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func enqueue(_ job: Job?, deadline: AsyncSequenceValidationDiagram.Clock.Instant, continuation: UnsafeContinuation<Void, Error>, token: Token) {
|
||||
|
||||
func enqueue(
|
||||
_ job: Job?,
|
||||
deadline: AsyncSequenceValidationDiagram.Clock.Instant,
|
||||
continuation: UnsafeContinuation<Void, Error>,
|
||||
token: Token
|
||||
) {
|
||||
state.withCriticalRegion { state in
|
||||
if state.queues[job] == nil, let job = job {
|
||||
state.jobs.append(job)
|
||||
}
|
||||
if state.items[token]?.isCancelled == true {
|
||||
let item: Item = .work(token, {
|
||||
continuation.resume(throwing: CancellationError())
|
||||
})
|
||||
let item: Item = .work(
|
||||
token,
|
||||
{
|
||||
continuation.resume(throwing: CancellationError())
|
||||
}
|
||||
)
|
||||
state.queues[job, default: []].append(item)
|
||||
state.items[token] = item
|
||||
} else {
|
||||
@@ -231,16 +246,27 @@ struct WorkQueue: Sendable {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func enqueue(_ job: Job?, deadline: AsyncSequenceValidationDiagram.Clock.Instant, continuation: UnsafeContinuation<String?, Error>, _ result: Result<String?, Error>, index: Int, token: Token) {
|
||||
|
||||
func enqueue(
|
||||
_ job: Job?,
|
||||
deadline: AsyncSequenceValidationDiagram.Clock.Instant,
|
||||
continuation: UnsafeContinuation<String?, Error>,
|
||||
_ result: Result<String?, Error>,
|
||||
index: Int,
|
||||
token: Token
|
||||
) {
|
||||
state.withCriticalRegion { state in
|
||||
if state.queues[job] == nil, let job = job {
|
||||
state.jobs.append(job)
|
||||
}
|
||||
if state.items[token]?.isCancelled == true {
|
||||
let item: Item = .work(token, {
|
||||
continuation.resume(returning: nil) // the input sequences should not throw cancellation errors
|
||||
})
|
||||
let item: Item = .work(
|
||||
token,
|
||||
{
|
||||
// the input sequences should not throw cancellation errors
|
||||
continuation.resume(returning: nil)
|
||||
}
|
||||
)
|
||||
state.queues[job, default: []].append(item)
|
||||
state.items[token] = item
|
||||
} else {
|
||||
@@ -250,7 +276,7 @@ struct WorkQueue: Sendable {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func enqueue(_ job: Job?, work: @Sendable @escaping () -> Void) {
|
||||
state.withCriticalRegion { state in
|
||||
if state.queues[job] == nil, let job = job {
|
||||
@@ -263,7 +289,7 @@ struct WorkQueue: Sendable {
|
||||
state.items[token] = item
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func drain() {
|
||||
// keep draining until there is no recursive work to do
|
||||
while true {
|
||||
@@ -279,7 +305,7 @@ struct WorkQueue: Sendable {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func advance() {
|
||||
// drain off the advancement
|
||||
var items: [Item] = state.withCriticalRegion { state in
|
||||
@@ -292,7 +318,7 @@ struct WorkQueue: Sendable {
|
||||
for item in items {
|
||||
item.run()
|
||||
}
|
||||
|
||||
|
||||
// and cleanup any additional recursive items
|
||||
drain()
|
||||
}
|
||||
|
||||
@@ -13,169 +13,169 @@ import AsyncAlgorithms
|
||||
import XCTest
|
||||
|
||||
final class TestInterspersed: XCTestCase {
|
||||
func test_interspersed() async {
|
||||
let source = [1, 2, 3, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3, 0, 4, 0, 5]
|
||||
let sequence = source.async.interspersed(with: 0)
|
||||
var actual = [Int]()
|
||||
func test_interspersed() async {
|
||||
let source = [1, 2, 3, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3, 0, 4, 0, 5]
|
||||
let sequence = source.async.interspersed(with: 0)
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_every() async {
|
||||
let source = [1, 2, 3, 4, 5, 6, 7, 8]
|
||||
let expected = [1, 2, 3, 0, 4, 5, 6, 0, 7, 8]
|
||||
let sequence = source.async.interspersed(every: 3, with: 0)
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_closure() async {
|
||||
let source = [1, 2, 3, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3, 0, 4, 0, 5]
|
||||
let sequence = source.async.interspersed(with: { 0 })
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_async_closure() async {
|
||||
let source = [1, 2, 3, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3, 0, 4, 0, 5]
|
||||
let sequence = source.async.interspersed {
|
||||
try! await Task.sleep(nanoseconds: 1000)
|
||||
return 0
|
||||
}
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_throwing_closure() async {
|
||||
let source = [1, 2]
|
||||
let expected = [1]
|
||||
var actual = [Int]()
|
||||
let sequence = source.async.interspersed(with: { throw Failure() })
|
||||
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
XCTFail()
|
||||
} catch {
|
||||
XCTAssertEqual(Failure(), error as? Failure)
|
||||
}
|
||||
let pastEnd = try! await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_async_throwing_closure() async {
|
||||
let source = [1, 2]
|
||||
let expected = [1]
|
||||
var actual = [Int]()
|
||||
let sequence = source.async.interspersed {
|
||||
try await Task.sleep(nanoseconds: 1000)
|
||||
throw Failure()
|
||||
}
|
||||
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
XCTFail()
|
||||
} catch {
|
||||
XCTAssertEqual(Failure(), error as? Failure)
|
||||
}
|
||||
let pastEnd = try! await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_empty() async {
|
||||
let source = [Int]()
|
||||
let expected = [Int]()
|
||||
let sequence = source.async.interspersed(with: 0)
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_with_throwing_upstream() async {
|
||||
let source = [1, 2, 3, -1, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3]
|
||||
var actual = [Int]()
|
||||
let sequence = source.async.map {
|
||||
try throwOn(-1, $0)
|
||||
}.interspersed(with: 0)
|
||||
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
XCTFail()
|
||||
} catch {
|
||||
XCTAssertEqual(Failure(), error as? Failure)
|
||||
}
|
||||
let pastEnd = try! await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_cancellation() async {
|
||||
let source = Indefinite(value: "test")
|
||||
let sequence = source.async.interspersed(with: "sep")
|
||||
let lockStepChannel = AsyncChannel<Void>()
|
||||
|
||||
await withTaskGroup(of: Void.self) { group in
|
||||
group.addTask {
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_every() async {
|
||||
let source = [1, 2, 3, 4, 5, 6, 7, 8]
|
||||
let expected = [1, 2, 3, 0, 4, 5, 6, 0, 7, 8]
|
||||
let sequence = source.async.interspersed(every: 3, with: 0)
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_closure() async {
|
||||
let source = [1, 2, 3, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3, 0, 4, 0, 5]
|
||||
let sequence = source.async.interspersed(with: { 0 })
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_async_closure() async {
|
||||
let source = [1, 2, 3, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3, 0, 4, 0, 5]
|
||||
let sequence = source.async.interspersed {
|
||||
try! await Task.sleep(nanoseconds: 1000)
|
||||
return 0
|
||||
}
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_throwing_closure() async {
|
||||
let source = [1, 2]
|
||||
let expected = [1]
|
||||
var actual = [Int]()
|
||||
let sequence = source.async.interspersed(with: { throw Failure() })
|
||||
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
XCTFail()
|
||||
} catch {
|
||||
XCTAssertEqual(Failure(), error as? Failure)
|
||||
}
|
||||
let pastEnd = try! await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_async_throwing_closure() async {
|
||||
let source = [1, 2]
|
||||
let expected = [1]
|
||||
var actual = [Int]()
|
||||
let sequence = source.async.interspersed {
|
||||
try await Task.sleep(nanoseconds: 1000)
|
||||
throw Failure()
|
||||
}
|
||||
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
XCTFail()
|
||||
} catch {
|
||||
XCTAssertEqual(Failure(), error as? Failure)
|
||||
}
|
||||
let pastEnd = try! await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_empty() async {
|
||||
let source = [Int]()
|
||||
let expected = [Int]()
|
||||
let sequence = source.async.interspersed(with: 0)
|
||||
var actual = [Int]()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
while let item = await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_interspersed_with_throwing_upstream() async {
|
||||
let source = [1, 2, 3, -1, 4, 5]
|
||||
let expected = [1, 0, 2, 0, 3]
|
||||
var actual = [Int]()
|
||||
let sequence = source.async.map {
|
||||
try throwOn(-1, $0)
|
||||
}.interspersed(with: 0)
|
||||
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iterator.next() {
|
||||
actual.append(item)
|
||||
}
|
||||
XCTFail()
|
||||
} catch {
|
||||
XCTAssertEqual(Failure(), error as? Failure)
|
||||
}
|
||||
let pastEnd = try! await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
XCTAssertEqual(actual, expected)
|
||||
}
|
||||
|
||||
func test_cancellation() async {
|
||||
let source = Indefinite(value: "test")
|
||||
let sequence = source.async.interspersed(with: "sep")
|
||||
let lockStepChannel = AsyncChannel<Void>()
|
||||
|
||||
await withTaskGroup(of: Void.self) { group in
|
||||
group.addTask {
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
let _ = await iterator.next()
|
||||
|
||||
// Information the parent task that we are consuming
|
||||
await lockStepChannel.send(())
|
||||
|
||||
while let _ = await iterator.next() {}
|
||||
|
||||
await lockStepChannel.send(())
|
||||
}
|
||||
|
||||
// Waiting until the child task started consuming
|
||||
_ = await lockStepChannel.first { _ in true }
|
||||
|
||||
// Now we cancel the child
|
||||
group.cancelAll()
|
||||
|
||||
await group.waitForAll()
|
||||
}
|
||||
let _ = await iterator.next()
|
||||
|
||||
// Information the parent task that we are consuming
|
||||
await lockStepChannel.send(())
|
||||
|
||||
while let _ = await iterator.next() {}
|
||||
|
||||
await lockStepChannel.send(())
|
||||
}
|
||||
|
||||
// Waiting until the child task started consuming
|
||||
_ = await lockStepChannel.first { _ in true }
|
||||
|
||||
// Now we cancel the child
|
||||
group.cancelAll()
|
||||
|
||||
await group.waitForAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -17,12 +17,12 @@ import XCTest
|
||||
public struct InfiniteAsyncSequence<Value: Sendable>: AsyncSequence, Sendable {
|
||||
public typealias Element = Value
|
||||
let value: Value
|
||||
|
||||
public struct AsyncIterator : AsyncIteratorProtocol, Sendable {
|
||||
|
||||
|
||||
public struct AsyncIterator: AsyncIteratorProtocol, Sendable {
|
||||
|
||||
@usableFromInline
|
||||
let value: Value
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() async throws -> Element? {
|
||||
guard !Task.isCancelled else {
|
||||
@@ -38,21 +38,33 @@ public struct InfiniteAsyncSequence<Value: Sendable>: AsyncSequence, Sendable {
|
||||
|
||||
final class _ThroughputMetric: NSObject, XCTMetric, @unchecked Sendable {
|
||||
var eventCount = 0
|
||||
|
||||
override init() { }
|
||||
|
||||
func reportMeasurements(from startTime: XCTPerformanceMeasurementTimestamp, to endTime: XCTPerformanceMeasurementTimestamp) throws -> [XCTPerformanceMeasurement] {
|
||||
return [XCTPerformanceMeasurement(identifier: "com.swift.AsyncAlgorithms.Throughput", displayName: "Throughput", doubleValue: Double(eventCount) / (endTime.date.timeIntervalSinceReferenceDate - startTime.date.timeIntervalSinceReferenceDate), unitSymbol: " Events/sec", polarity: .prefersLarger)]
|
||||
|
||||
override init() {}
|
||||
|
||||
func reportMeasurements(
|
||||
from startTime: XCTPerformanceMeasurementTimestamp,
|
||||
to endTime: XCTPerformanceMeasurementTimestamp
|
||||
) throws -> [XCTPerformanceMeasurement] {
|
||||
return [
|
||||
XCTPerformanceMeasurement(
|
||||
identifier: "com.swift.AsyncAlgorithms.Throughput",
|
||||
displayName: "Throughput",
|
||||
doubleValue: Double(eventCount)
|
||||
/ (endTime.date.timeIntervalSinceReferenceDate - startTime.date.timeIntervalSinceReferenceDate),
|
||||
unitSymbol: " Events/sec",
|
||||
polarity: .prefersLarger
|
||||
)
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
func copy(with zone: NSZone? = nil) -> Any {
|
||||
return self
|
||||
}
|
||||
|
||||
|
||||
func willBeginMeasuring() {
|
||||
eventCount = 0
|
||||
}
|
||||
func didStopMeasuring() { }
|
||||
func didStopMeasuring() {}
|
||||
}
|
||||
|
||||
extension XCTestCase {
|
||||
@@ -85,7 +97,9 @@ extension XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
public func measureThrowingChannelThroughput<Output: Sendable>(output: @Sendable @escaping @autoclosure () -> Output) async {
|
||||
public func measureThrowingChannelThroughput<Output: Sendable>(
|
||||
output: @Sendable @escaping @autoclosure () -> Output
|
||||
) async {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
@@ -114,14 +128,17 @@ extension XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>( output: @autoclosure () -> Output, _ sequenceBuilder: (InfiniteAsyncSequence<Output>) -> S) async where S: Sendable {
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>(
|
||||
output: @autoclosure () -> Output,
|
||||
_ sequenceBuilder: (InfiniteAsyncSequence<Output>) -> S
|
||||
) async where S: Sendable {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
|
||||
measure(metrics: [metric]) {
|
||||
let infSeq = InfiniteAsyncSequence(value: output())
|
||||
let seq = sequenceBuilder(infSeq)
|
||||
|
||||
|
||||
let exp = self.expectation(description: "Finished")
|
||||
let iterTask = Task<Int, Error> {
|
||||
var eventCount = 0
|
||||
@@ -137,16 +154,20 @@ extension XCTestCase {
|
||||
self.wait(for: [exp], timeout: sampleTime * 2)
|
||||
}
|
||||
}
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>(firstOutput: @autoclosure () -> Output, secondOutput: @autoclosure () -> Output, _ sequenceBuilder: (InfiniteAsyncSequence<Output>, InfiniteAsyncSequence<Output>) -> S) async where S: Sendable {
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>(
|
||||
firstOutput: @autoclosure () -> Output,
|
||||
secondOutput: @autoclosure () -> Output,
|
||||
_ sequenceBuilder: (InfiniteAsyncSequence<Output>, InfiniteAsyncSequence<Output>) -> S
|
||||
) async where S: Sendable {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
|
||||
measure(metrics: [metric]) {
|
||||
let firstInfSeq = InfiniteAsyncSequence(value: firstOutput())
|
||||
let secondInfSeq = InfiniteAsyncSequence(value: secondOutput())
|
||||
let seq = sequenceBuilder(firstInfSeq, secondInfSeq)
|
||||
|
||||
|
||||
let exp = self.expectation(description: "Finished")
|
||||
let iterTask = Task<Int, Error> {
|
||||
var eventCount = 0
|
||||
@@ -162,17 +183,23 @@ extension XCTestCase {
|
||||
self.wait(for: [exp], timeout: sampleTime * 2)
|
||||
}
|
||||
}
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>(firstOutput: @autoclosure () -> Output, secondOutput: @autoclosure () -> Output, thirdOutput: @autoclosure () -> Output, _ sequenceBuilder: (InfiniteAsyncSequence<Output>, InfiniteAsyncSequence<Output>, InfiniteAsyncSequence<Output>) -> S) async where S: Sendable {
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>(
|
||||
firstOutput: @autoclosure () -> Output,
|
||||
secondOutput: @autoclosure () -> Output,
|
||||
thirdOutput: @autoclosure () -> Output,
|
||||
_ sequenceBuilder: (InfiniteAsyncSequence<Output>, InfiniteAsyncSequence<Output>, InfiniteAsyncSequence<Output>)
|
||||
-> S
|
||||
) async where S: Sendable {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
|
||||
measure(metrics: [metric]) {
|
||||
let firstInfSeq = InfiniteAsyncSequence(value: firstOutput())
|
||||
let secondInfSeq = InfiniteAsyncSequence(value: secondOutput())
|
||||
let thirdInfSeq = InfiniteAsyncSequence(value: thirdOutput())
|
||||
let seq = sequenceBuilder(firstInfSeq, secondInfSeq, thirdInfSeq)
|
||||
|
||||
|
||||
let exp = self.expectation(description: "Finished")
|
||||
let iterTask = Task<Int, Error> {
|
||||
var eventCount = 0
|
||||
@@ -187,16 +214,19 @@ extension XCTestCase {
|
||||
iterTask.cancel()
|
||||
self.wait(for: [exp], timeout: sampleTime * 2)
|
||||
}
|
||||
}
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Source: AsyncSequence>( source: Source, _ sequenceBuilder: (Source) -> S) async where S: Sendable, Source: Sendable {
|
||||
}
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Source: AsyncSequence>(
|
||||
source: Source,
|
||||
_ sequenceBuilder: (Source) -> S
|
||||
) async where S: Sendable, Source: Sendable {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
|
||||
measure(metrics: [metric]) {
|
||||
let infSeq = source
|
||||
let seq = sequenceBuilder(infSeq)
|
||||
|
||||
|
||||
let exp = self.expectation(description: "Finished")
|
||||
let iterTask = Task<Int, Error> {
|
||||
var eventCount = 0
|
||||
@@ -215,26 +245,26 @@ extension XCTestCase {
|
||||
}
|
||||
|
||||
final class TestMeasurements: XCTestCase {
|
||||
struct PassthroughSequence<S: AsyncSequence> : AsyncSequence, Sendable where S : Sendable, S.AsyncIterator : Sendable {
|
||||
struct PassthroughSequence<S: AsyncSequence>: AsyncSequence, Sendable where S: Sendable, S.AsyncIterator: Sendable {
|
||||
typealias Element = S.Element
|
||||
|
||||
struct AsyncIterator : AsyncIteratorProtocol, Sendable {
|
||||
|
||||
|
||||
struct AsyncIterator: AsyncIteratorProtocol, Sendable {
|
||||
|
||||
@usableFromInline
|
||||
var base : S.AsyncIterator
|
||||
|
||||
var base: S.AsyncIterator
|
||||
|
||||
@inlinable
|
||||
mutating func next() async throws -> Element? {
|
||||
return try await base.next()
|
||||
}
|
||||
}
|
||||
|
||||
let base : S
|
||||
|
||||
let base: S
|
||||
func makeAsyncIterator() -> AsyncIterator {
|
||||
.init(base: base.makeAsyncIterator())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func testThroughputTesting() async {
|
||||
await self.measureSequenceThroughput(output: 1) {
|
||||
PassthroughSequence(base: $0)
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
|
||||
import XCTest
|
||||
|
||||
fileprivate enum _XCTAssertion {
|
||||
private enum _XCTAssertion {
|
||||
case equal
|
||||
case equalWithAccuracy
|
||||
case identical
|
||||
@@ -30,9 +30,9 @@ fileprivate enum _XCTAssertion {
|
||||
case fail
|
||||
case throwsError
|
||||
case noThrow
|
||||
|
||||
|
||||
var name: String? {
|
||||
switch(self) {
|
||||
switch self {
|
||||
case .equal: return "XCTAssertEqual"
|
||||
case .equalWithAccuracy: return "XCTAssertEqual"
|
||||
case .identical: return "XCTAssertIdentical"
|
||||
@@ -55,18 +55,18 @@ fileprivate enum _XCTAssertion {
|
||||
}
|
||||
}
|
||||
|
||||
fileprivate enum _XCTAssertionResult {
|
||||
private enum _XCTAssertionResult {
|
||||
case success
|
||||
case expectedFailure(String?)
|
||||
case unexpectedFailure(Swift.Error)
|
||||
|
||||
|
||||
var isExpected: Bool {
|
||||
switch self {
|
||||
case .unexpectedFailure(_): return false
|
||||
default: return true
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func failureDescription(_ assertion: _XCTAssertion) -> String {
|
||||
let explanation: String
|
||||
switch self {
|
||||
@@ -75,23 +75,28 @@ fileprivate enum _XCTAssertionResult {
|
||||
case .expectedFailure(_): explanation = "failed"
|
||||
case .unexpectedFailure(let error): explanation = "threw error \"\(error)\""
|
||||
}
|
||||
|
||||
if let name = assertion.name {
|
||||
return "\(name) \(explanation)"
|
||||
} else {
|
||||
|
||||
guard let name = assertion.name else {
|
||||
return explanation
|
||||
}
|
||||
return "\(name) \(explanation)"
|
||||
}
|
||||
}
|
||||
|
||||
private func _XCTEvaluateAssertion(_ assertion: _XCTAssertion, message: () -> String, file: StaticString, line: UInt, expression: () throws -> _XCTAssertionResult) {
|
||||
private func _XCTEvaluateAssertion(
|
||||
_ assertion: _XCTAssertion,
|
||||
message: () -> String,
|
||||
file: StaticString,
|
||||
line: UInt,
|
||||
expression: () throws -> _XCTAssertionResult
|
||||
) {
|
||||
let result: _XCTAssertionResult
|
||||
do {
|
||||
result = try expression()
|
||||
} catch {
|
||||
result = .unexpectedFailure(error)
|
||||
}
|
||||
|
||||
|
||||
switch result {
|
||||
case .success:
|
||||
return
|
||||
@@ -100,22 +105,34 @@ private func _XCTEvaluateAssertion(_ assertion: _XCTAssertion, message: () -> St
|
||||
}
|
||||
}
|
||||
|
||||
fileprivate func _XCTAssertEqual<T>(_ expression1: () throws -> T, _ expression2: () throws -> T, _ equal: (T, T) -> Bool, _ message: () -> String, file: StaticString = #filePath, line: UInt = #line) {
|
||||
private func _XCTAssertEqual<T>(
|
||||
_ expression1: () throws -> T,
|
||||
_ expression2: () throws -> T,
|
||||
_ equal: (T, T) -> Bool,
|
||||
_ message: () -> String,
|
||||
file: StaticString = #filePath,
|
||||
line: UInt = #line
|
||||
) {
|
||||
_XCTEvaluateAssertion(.equal, message: message, file: file, line: line) {
|
||||
let (value1, value2) = (try expression1(), try expression2())
|
||||
if equal(value1, value2) {
|
||||
return .success
|
||||
} else {
|
||||
guard equal(value1, value2) else {
|
||||
return .expectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
|
||||
}
|
||||
return .success
|
||||
}
|
||||
}
|
||||
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable>(_ expression1: @autoclosure () throws -> (A, B), _ expression2: @autoclosure () throws -> (A, B), _ message: @autoclosure () -> String = "", file: StaticString = #filePath, line: UInt = #line) {
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable>(
|
||||
_ expression1: @autoclosure () throws -> (A, B),
|
||||
_ expression2: @autoclosure () throws -> (A, B),
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #filePath,
|
||||
line: UInt = #line
|
||||
) {
|
||||
_XCTAssertEqual(expression1, expression2, { $0 == $1 }, message, file: file, line: line)
|
||||
}
|
||||
|
||||
fileprivate func ==<A: Equatable, B: Equatable>(_ lhs: [(A, B)], _ rhs: [(A, B)]) -> Bool {
|
||||
private func == <A: Equatable, B: Equatable>(_ lhs: [(A, B)], _ rhs: [(A, B)]) -> Bool {
|
||||
guard lhs.count == rhs.count else {
|
||||
return false
|
||||
}
|
||||
@@ -127,15 +144,27 @@ fileprivate func ==<A: Equatable, B: Equatable>(_ lhs: [(A, B)], _ rhs: [(A, B)]
|
||||
return true
|
||||
}
|
||||
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable>(_ expression1: @autoclosure () throws -> [(A, B)], _ expression2: @autoclosure () throws -> [(A, B)], _ message: @autoclosure () -> String = "", file: StaticString = #filePath, line: UInt = #line) {
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable>(
|
||||
_ expression1: @autoclosure () throws -> [(A, B)],
|
||||
_ expression2: @autoclosure () throws -> [(A, B)],
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #filePath,
|
||||
line: UInt = #line
|
||||
) {
|
||||
_XCTAssertEqual(expression1, expression2, { $0 == $1 }, message, file: file, line: line)
|
||||
}
|
||||
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable, C: Equatable>(_ expression1: @autoclosure () throws -> (A, B, C), _ expression2: @autoclosure () throws -> (A, B, C), _ message: @autoclosure () -> String = "", file: StaticString = #filePath, line: UInt = #line) {
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable, C: Equatable>(
|
||||
_ expression1: @autoclosure () throws -> (A, B, C),
|
||||
_ expression2: @autoclosure () throws -> (A, B, C),
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #filePath,
|
||||
line: UInt = #line
|
||||
) {
|
||||
_XCTAssertEqual(expression1, expression2, { $0 == $1 }, message, file: file, line: line)
|
||||
}
|
||||
|
||||
fileprivate func ==<A: Equatable, B: Equatable, C: Equatable>(_ lhs: [(A, B, C)], _ rhs: [(A, B, C)]) -> Bool {
|
||||
private func == <A: Equatable, B: Equatable, C: Equatable>(_ lhs: [(A, B, C)], _ rhs: [(A, B, C)]) -> Bool {
|
||||
guard lhs.count == rhs.count else {
|
||||
return false
|
||||
}
|
||||
@@ -147,48 +176,58 @@ fileprivate func ==<A: Equatable, B: Equatable, C: Equatable>(_ lhs: [(A, B, C)]
|
||||
return true
|
||||
}
|
||||
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable, C: Equatable>(_ expression1: @autoclosure () throws -> [(A, B, C)], _ expression2: @autoclosure () throws -> [(A, B, C)], _ message: @autoclosure () -> String = "", file: StaticString = #filePath, line: UInt = #line) {
|
||||
public func XCTAssertEqual<A: Equatable, B: Equatable, C: Equatable>(
|
||||
_ expression1: @autoclosure () throws -> [(A, B, C)],
|
||||
_ expression2: @autoclosure () throws -> [(A, B, C)],
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #filePath,
|
||||
line: UInt = #line
|
||||
) {
|
||||
_XCTAssertEqual(expression1, expression2, { $0 == $1 }, message, file: file, line: line)
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
|
||||
internal func XCTAssertThrowsError<T>(
|
||||
_ expression: @autoclosure () async throws -> T,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line,
|
||||
verify: (Error) -> Void = { _ in }
|
||||
_ expression: @autoclosure () async throws -> T,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line,
|
||||
verify: (Error) -> Void = { _ in }
|
||||
) async {
|
||||
do {
|
||||
_ = try await expression()
|
||||
XCTFail("Expression did not throw error", file: file, line: line)
|
||||
} catch {
|
||||
verify(error)
|
||||
}
|
||||
do {
|
||||
_ = try await expression()
|
||||
XCTFail("Expression did not throw error", file: file, line: line)
|
||||
} catch {
|
||||
verify(error)
|
||||
}
|
||||
}
|
||||
|
||||
class WaiterDelegate: NSObject, XCTWaiterDelegate {
|
||||
let state: ManagedCriticalState<UnsafeContinuation<Void, Never>?> = ManagedCriticalState(nil)
|
||||
|
||||
|
||||
init(_ continuation: UnsafeContinuation<Void, Never>) {
|
||||
state.withCriticalRegion { $0 = continuation }
|
||||
}
|
||||
|
||||
|
||||
func waiter(_ waiter: XCTWaiter, didFulfillInvertedExpectation expectation: XCTestExpectation) {
|
||||
resume()
|
||||
}
|
||||
|
||||
|
||||
func waiter(_ waiter: XCTWaiter, didTimeoutWithUnfulfilledExpectations unfulfilledExpectations: [XCTestExpectation]) {
|
||||
resume()
|
||||
}
|
||||
|
||||
func waiter(_ waiter: XCTWaiter, fulfillmentDidViolateOrderingConstraintsFor expectation: XCTestExpectation, requiredExpectation: XCTestExpectation) {
|
||||
|
||||
func waiter(
|
||||
_ waiter: XCTWaiter,
|
||||
fulfillmentDidViolateOrderingConstraintsFor expectation: XCTestExpectation,
|
||||
requiredExpectation: XCTestExpectation
|
||||
) {
|
||||
resume()
|
||||
}
|
||||
|
||||
|
||||
func nestedWaiter(_ waiter: XCTWaiter, wasInterruptedByTimedOutWaiter outerWaiter: XCTWaiter) {
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
func resume() {
|
||||
let continuation = state.withCriticalRegion { continuation in
|
||||
defer { continuation = nil }
|
||||
@@ -200,7 +239,13 @@ class WaiterDelegate: NSObject, XCTWaiterDelegate {
|
||||
|
||||
extension XCTestCase {
|
||||
@_disfavoredOverload
|
||||
func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
|
||||
func fulfillment(
|
||||
of expectations: [XCTestExpectation],
|
||||
timeout: TimeInterval,
|
||||
enforceOrder: Bool = false,
|
||||
file: StaticString = #file,
|
||||
line: Int = #line
|
||||
) async {
|
||||
return await withUnsafeContinuation { continuation in
|
||||
let delegate = WaiterDelegate(continuation)
|
||||
let waiter = XCTWaiter(delegate: delegate)
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
struct Failure: Error, Equatable { }
|
||||
struct Failure: Error, Equatable {}
|
||||
|
||||
func throwOn<T: Equatable>(_ toThrowOn: T, _ value: T) throws -> T {
|
||||
if value == toThrowOn {
|
||||
|
||||
@@ -17,9 +17,9 @@ public struct Gate: Sendable {
|
||||
case open
|
||||
case pending(UnsafeContinuation<Void, Never>)
|
||||
}
|
||||
|
||||
|
||||
let state = ManagedCriticalState(State.closed)
|
||||
|
||||
|
||||
public func `open`() {
|
||||
state.withCriticalRegion { state -> UnsafeContinuation<Void, Never>? in
|
||||
switch state {
|
||||
@@ -34,7 +34,7 @@ public struct Gate: Sendable {
|
||||
}
|
||||
}?.resume()
|
||||
}
|
||||
|
||||
|
||||
public func enter() async {
|
||||
var other: UnsafeContinuation<Void, Never>?
|
||||
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
|
||||
@@ -45,7 +45,7 @@ public struct Gate: Sendable {
|
||||
return nil
|
||||
case .open:
|
||||
state = .closed
|
||||
return continuation
|
||||
return continuation
|
||||
case .pending(let existing):
|
||||
other = existing
|
||||
state = .pending(continuation)
|
||||
|
||||
@@ -13,7 +13,7 @@ public struct GatedSequence<Element> {
|
||||
let elements: [Element]
|
||||
let gates: [Gate]
|
||||
var index = 0
|
||||
|
||||
|
||||
public mutating func advance() {
|
||||
defer { index += 1 }
|
||||
guard index < gates.count else {
|
||||
@@ -21,7 +21,7 @@ public struct GatedSequence<Element> {
|
||||
}
|
||||
gates[index].open()
|
||||
}
|
||||
|
||||
|
||||
public init(_ elements: [Element]) {
|
||||
self.elements = elements
|
||||
self.gates = elements.map { _ in Gate() }
|
||||
@@ -31,11 +31,11 @@ public struct GatedSequence<Element> {
|
||||
extension GatedSequence: AsyncSequence {
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
var gatedElements: [(Element, Gate)]
|
||||
|
||||
|
||||
init(elements: [Element], gates: [Gate]) {
|
||||
gatedElements = Array(zip(elements, gates))
|
||||
}
|
||||
|
||||
|
||||
public mutating func next() async -> Element? {
|
||||
guard gatedElements.count > 0 else {
|
||||
return nil
|
||||
@@ -45,10 +45,10 @@ extension GatedSequence: AsyncSequence {
|
||||
return element
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(elements: elements, gates: gates)
|
||||
}
|
||||
}
|
||||
|
||||
extension GatedSequence: Sendable where Element: Sendable { }
|
||||
extension GatedSequence: Sendable where Element: Sendable {}
|
||||
@@ -11,11 +11,11 @@
|
||||
|
||||
struct Indefinite<Element: Sendable>: Sequence, IteratorProtocol, Sendable {
|
||||
let value: Element
|
||||
|
||||
|
||||
func next() -> Element? {
|
||||
return value
|
||||
}
|
||||
|
||||
|
||||
func makeIterator() -> Indefinite<Element> {
|
||||
self
|
||||
}
|
||||
|
||||
@@ -14,78 +14,78 @@ import AsyncAlgorithms
|
||||
public struct ManualClock: Clock {
|
||||
public struct Step: DurationProtocol {
|
||||
fileprivate var rawValue: Int
|
||||
|
||||
|
||||
fileprivate init(_ rawValue: Int) {
|
||||
self.rawValue = rawValue
|
||||
}
|
||||
|
||||
|
||||
public static func + (lhs: ManualClock.Step, rhs: ManualClock.Step) -> ManualClock.Step {
|
||||
return .init(lhs.rawValue + rhs.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public static func - (lhs: ManualClock.Step, rhs: ManualClock.Step) -> ManualClock.Step {
|
||||
.init(lhs.rawValue - rhs.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public static func / (lhs: ManualClock.Step, rhs: Int) -> ManualClock.Step {
|
||||
.init(lhs.rawValue / rhs)
|
||||
}
|
||||
|
||||
|
||||
public static func * (lhs: ManualClock.Step, rhs: Int) -> ManualClock.Step {
|
||||
.init(lhs.rawValue * rhs)
|
||||
}
|
||||
|
||||
|
||||
public static func / (lhs: ManualClock.Step, rhs: ManualClock.Step) -> Double {
|
||||
Double(lhs.rawValue) / Double(rhs.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public static func < (lhs: ManualClock.Step, rhs: ManualClock.Step) -> Bool {
|
||||
lhs.rawValue < rhs.rawValue
|
||||
}
|
||||
|
||||
|
||||
public static var zero: ManualClock.Step { .init(0) }
|
||||
|
||||
|
||||
public static func steps(_ amount: Int) -> Step {
|
||||
return Step(amount)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public struct Instant: InstantProtocol, CustomStringConvertible {
|
||||
public typealias Duration = Step
|
||||
|
||||
|
||||
internal let rawValue: Int
|
||||
|
||||
|
||||
internal init(_ rawValue: Int) {
|
||||
self.rawValue = rawValue
|
||||
}
|
||||
|
||||
|
||||
public static func < (lhs: ManualClock.Instant, rhs: ManualClock.Instant) -> Bool {
|
||||
return lhs.rawValue < rhs.rawValue
|
||||
}
|
||||
|
||||
|
||||
public func advanced(by duration: ManualClock.Step) -> ManualClock.Instant {
|
||||
.init(rawValue + duration.rawValue)
|
||||
}
|
||||
|
||||
|
||||
public func duration(to other: ManualClock.Instant) -> ManualClock.Step {
|
||||
.init(other.rawValue - rawValue)
|
||||
}
|
||||
|
||||
|
||||
public var description: String {
|
||||
return "tick \(rawValue)"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fileprivate struct Wakeup {
|
||||
let generation: Int
|
||||
let continuation: UnsafeContinuation<Void, Error>
|
||||
let deadline: Instant
|
||||
}
|
||||
|
||||
|
||||
fileprivate enum Scheduled: Hashable, Comparable, CustomStringConvertible {
|
||||
case cancelled(Int)
|
||||
case wakeup(Wakeup)
|
||||
|
||||
|
||||
func hash(into hasher: inout Hasher) {
|
||||
switch self {
|
||||
case .cancelled(let generation):
|
||||
@@ -94,14 +94,14 @@ public struct ManualClock: Clock {
|
||||
hasher.combine(wakeup.generation)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .cancelled: return "Cancelled wakeup"
|
||||
case .wakeup(let wakeup): return "Wakeup at \(wakeup.deadline)"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static func == (_ lhs: Scheduled, _ rhs: Scheduled) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case (.cancelled(let lhsGen), .cancelled(let rhsGen)):
|
||||
@@ -114,7 +114,7 @@ public struct ManualClock: Clock {
|
||||
return lhs.generation == rhs.generation
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static func < (lhs: ManualClock.Scheduled, rhs: ManualClock.Scheduled) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case (.cancelled(let lhsGen), .cancelled(let rhsGen)):
|
||||
@@ -127,14 +127,14 @@ public struct ManualClock: Clock {
|
||||
return lhs.generation < rhs.generation
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var deadline: Instant? {
|
||||
switch self {
|
||||
case .cancelled: return nil
|
||||
case .wakeup(let wakeup): return wakeup.deadline
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func resume() {
|
||||
switch self {
|
||||
case .wakeup(let wakeup):
|
||||
@@ -144,54 +144,52 @@ public struct ManualClock: Clock {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fileprivate struct State {
|
||||
var generation = 0
|
||||
var scheduled = Set<Scheduled>()
|
||||
var now = Instant(0)
|
||||
var hasSleepers = false
|
||||
}
|
||||
|
||||
|
||||
fileprivate let state = ManagedCriticalState(State())
|
||||
|
||||
|
||||
public var now: Instant {
|
||||
state.withCriticalRegion { $0.now }
|
||||
}
|
||||
|
||||
|
||||
public var minimumResolution: Step { return .zero }
|
||||
|
||||
public init() { }
|
||||
|
||||
public init() {}
|
||||
|
||||
fileprivate func cancel(_ generation: Int) {
|
||||
state.withCriticalRegion { state -> UnsafeContinuation<Void, Error>? in
|
||||
if let existing = state.scheduled.remove(.cancelled(generation)) {
|
||||
switch existing {
|
||||
case .wakeup(let wakeup):
|
||||
return wakeup.continuation
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
} else {
|
||||
guard let existing = state.scheduled.remove(.cancelled(generation)) else {
|
||||
// insert the cancelled state for when it comes in to be scheduled as a wakeup
|
||||
state.scheduled.insert(.cancelled(generation))
|
||||
return nil
|
||||
}
|
||||
switch existing {
|
||||
case .wakeup(let wakeup):
|
||||
return wakeup.continuation
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}?.resume(throwing: CancellationError())
|
||||
}
|
||||
|
||||
|
||||
var hasSleepers: Bool {
|
||||
state.withCriticalRegion { $0.hasSleepers }
|
||||
}
|
||||
|
||||
|
||||
public func advance() {
|
||||
let pending = state.withCriticalRegion { state -> Set<Scheduled> in
|
||||
state.now = state.now.advanced(by: .steps(1))
|
||||
let pending = state.scheduled.filter { item in
|
||||
if let deadline = item.deadline {
|
||||
return deadline <= state.now
|
||||
} else {
|
||||
guard let deadline = item.deadline else {
|
||||
return false
|
||||
}
|
||||
return deadline <= state.now
|
||||
}
|
||||
state.scheduled.subtract(pending)
|
||||
if pending.count > 0 {
|
||||
@@ -203,42 +201,40 @@ public struct ManualClock: Clock {
|
||||
item.resume()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func advance(by steps: Step) {
|
||||
for _ in 0..<steps.rawValue {
|
||||
advance()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fileprivate func schedule(_ generation: Int, continuation: UnsafeContinuation<Void, Error>, deadline: Instant) {
|
||||
let resumption = state.withCriticalRegion { state -> (UnsafeContinuation<Void, Error>, Result<Void, Error>)? in
|
||||
let wakeup = Wakeup(generation: generation, continuation: continuation, deadline: deadline)
|
||||
if let existing = state.scheduled.remove(.wakeup(wakeup)) {
|
||||
switch existing {
|
||||
case .wakeup:
|
||||
fatalError()
|
||||
case .cancelled:
|
||||
// dont bother adding it back because it has been cancelled before we got here
|
||||
return (continuation, .failure(CancellationError()))
|
||||
}
|
||||
} else {
|
||||
guard let existing = state.scheduled.remove(.wakeup(wakeup)) else {
|
||||
// there is no cancelled placeholder so let it run free
|
||||
if deadline > state.now {
|
||||
// the deadline is in the future so run it then
|
||||
state.hasSleepers = true
|
||||
state.scheduled.insert(.wakeup(wakeup))
|
||||
return nil
|
||||
} else {
|
||||
guard deadline > state.now else {
|
||||
// the deadline is now or in the past so run it immediately
|
||||
return (continuation, .success(()))
|
||||
}
|
||||
// the deadline is in the future so run it then
|
||||
state.hasSleepers = true
|
||||
state.scheduled.insert(.wakeup(wakeup))
|
||||
return nil
|
||||
}
|
||||
switch existing {
|
||||
case .wakeup:
|
||||
fatalError()
|
||||
case .cancelled:
|
||||
// dont bother adding it back because it has been cancelled before we got here
|
||||
return (continuation, .failure(CancellationError()))
|
||||
}
|
||||
}
|
||||
if let resumption = resumption {
|
||||
resumption.0.resume(with: resumption.1)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func sleep(until deadline: Instant, tolerance: Step? = nil) async throws {
|
||||
let generation = state.withCriticalRegion { state -> Int in
|
||||
defer { state.generation += 1 }
|
||||
|
||||
@@ -13,7 +13,7 @@ final class ReportingSequence<Element>: Sequence, IteratorProtocol {
|
||||
enum Event: Equatable, CustomStringConvertible {
|
||||
case next
|
||||
case makeIterator
|
||||
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .next: return "next()"
|
||||
@@ -21,14 +21,14 @@ final class ReportingSequence<Element>: Sequence, IteratorProtocol {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var events = [Event]()
|
||||
var elements: [Element]
|
||||
|
||||
init(_ elements: [Element]) {
|
||||
self.elements = elements
|
||||
}
|
||||
|
||||
|
||||
func next() -> Element? {
|
||||
events.append(.next)
|
||||
guard elements.count > 0 else {
|
||||
@@ -36,7 +36,7 @@ final class ReportingSequence<Element>: Sequence, IteratorProtocol {
|
||||
}
|
||||
return elements.removeFirst()
|
||||
}
|
||||
|
||||
|
||||
func makeIterator() -> ReportingSequence {
|
||||
events.append(.makeIterator)
|
||||
return self
|
||||
@@ -47,7 +47,7 @@ final class ReportingAsyncSequence<Element: Sendable>: AsyncSequence, AsyncItera
|
||||
enum Event: Equatable, CustomStringConvertible {
|
||||
case next
|
||||
case makeAsyncIterator
|
||||
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .next: return "next()"
|
||||
@@ -55,14 +55,14 @@ final class ReportingAsyncSequence<Element: Sendable>: AsyncSequence, AsyncItera
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var events = [Event]()
|
||||
var elements: [Element]
|
||||
|
||||
init(_ elements: [Element]) {
|
||||
self.elements = elements
|
||||
}
|
||||
|
||||
|
||||
func next() async -> Element? {
|
||||
events.append(.next)
|
||||
guard elements.count > 0 else {
|
||||
@@ -70,7 +70,7 @@ final class ReportingAsyncSequence<Element: Sendable>: AsyncSequence, AsyncItera
|
||||
}
|
||||
return elements.removeFirst()
|
||||
}
|
||||
|
||||
|
||||
func makeAsyncIterator() -> ReportingAsyncSequence {
|
||||
events.append(.makeAsyncIterator)
|
||||
return self
|
||||
|
||||
@@ -17,17 +17,17 @@ public struct Validator<Element: Sendable>: Sendable {
|
||||
case ready
|
||||
case pending(UnsafeContinuation<Void, Never>)
|
||||
}
|
||||
|
||||
|
||||
private struct State: Sendable {
|
||||
var collected = [Element]()
|
||||
var failure: Error?
|
||||
var ready: Ready = .idle
|
||||
}
|
||||
|
||||
|
||||
private struct Envelope<Contents>: @unchecked Sendable {
|
||||
var contents: Contents
|
||||
}
|
||||
|
||||
|
||||
private let state = ManagedCriticalState(State())
|
||||
|
||||
private func ready(_ apply: (inout State) -> Void) {
|
||||
@@ -45,7 +45,7 @@ public struct Validator<Element: Sendable>: Sendable {
|
||||
}
|
||||
}?.resume()
|
||||
}
|
||||
|
||||
|
||||
internal func step() async {
|
||||
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
|
||||
state.withCriticalRegion { state -> UnsafeContinuation<Void, Never>? in
|
||||
@@ -64,17 +64,20 @@ public struct Validator<Element: Sendable>: Sendable {
|
||||
}
|
||||
|
||||
let onEvent: (@Sendable (Result<Element?, Error>) async -> Void)?
|
||||
|
||||
|
||||
init(onEvent: @Sendable @escaping (Result<Element?, Error>) async -> Void) {
|
||||
|
||||
self.onEvent = onEvent
|
||||
}
|
||||
|
||||
|
||||
public init() {
|
||||
self.onEvent = nil
|
||||
}
|
||||
|
||||
public func test<S: AsyncSequence>(_ sequence: S, onFinish: @Sendable @escaping (inout S.AsyncIterator) async -> Void) where S.Element == Element {
|
||||
|
||||
public func test<S: AsyncSequence>(
|
||||
_ sequence: S,
|
||||
onFinish: @Sendable @escaping (inout S.AsyncIterator) async -> Void
|
||||
) where S.Element == Element {
|
||||
let envelope = Envelope(contents: sequence)
|
||||
Task {
|
||||
var iterator = envelope.contents.makeAsyncIterator()
|
||||
@@ -97,18 +100,18 @@ public struct Validator<Element: Sendable>: Sendable {
|
||||
await onFinish(&iterator)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func validate() async -> [Element] {
|
||||
await step()
|
||||
return current
|
||||
}
|
||||
|
||||
|
||||
public var current: [Element] {
|
||||
return state.withCriticalRegion { state in
|
||||
return state.collected
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public var failure: Error? {
|
||||
return state.withCriticalRegion { state in
|
||||
return state.failure
|
||||
|
||||
@@ -13,7 +13,7 @@ extension AsyncSequence {
|
||||
func violatingSpecification(returningPastEndIteration element: Element) -> SpecificationViolatingSequence<Self> {
|
||||
SpecificationViolatingSequence(self, kind: .producing(element))
|
||||
}
|
||||
|
||||
|
||||
func violatingSpecification(throwingPastEndIteration error: Error) -> SpecificationViolatingSequence<Self> {
|
||||
SpecificationViolatingSequence(self, kind: .throwing(error))
|
||||
}
|
||||
@@ -24,10 +24,10 @@ struct SpecificationViolatingSequence<Base: AsyncSequence> {
|
||||
case producing(Base.Element)
|
||||
case throwing(Error)
|
||||
}
|
||||
|
||||
|
||||
let base: Base
|
||||
let kind: Kind
|
||||
|
||||
|
||||
init(_ base: Base, kind: Kind) {
|
||||
self.base = base
|
||||
self.kind = kind
|
||||
@@ -36,13 +36,13 @@ struct SpecificationViolatingSequence<Base: AsyncSequence> {
|
||||
|
||||
extension SpecificationViolatingSequence: AsyncSequence {
|
||||
typealias Element = Base.Element
|
||||
|
||||
|
||||
struct Iterator: AsyncIteratorProtocol {
|
||||
var iterator: Base.AsyncIterator
|
||||
let kind: Kind
|
||||
var finished = false
|
||||
var violated = false
|
||||
|
||||
|
||||
mutating func next() async throws -> Element? {
|
||||
if finished {
|
||||
if violated {
|
||||
@@ -66,7 +66,7 @@ extension SpecificationViolatingSequence: AsyncSequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func makeAsyncIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeAsyncIterator(), kind: kind)
|
||||
}
|
||||
|
||||
@@ -86,9 +86,9 @@ final class TestAdjacentPairs: XCTestCase {
|
||||
}
|
||||
finished.fulfill()
|
||||
}
|
||||
|
||||
|
||||
// ensure the other task actually starts
|
||||
|
||||
|
||||
await fulfillment(of: [iterated], timeout: 1.0)
|
||||
// cancellation should ensure the loop finishes
|
||||
// without regards to the remaining underlying sequence
|
||||
|
||||
@@ -172,7 +172,10 @@ final class TestBuffer: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func test_given_a_buffered_with_unbounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled() async {
|
||||
func
|
||||
test_given_a_buffered_with_unbounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled()
|
||||
async
|
||||
{
|
||||
// Given
|
||||
let buffered = Indefinite(value: 1).async.buffer(policy: .unbounded)
|
||||
|
||||
@@ -292,7 +295,10 @@ final class TestBuffer: XCTestCase {
|
||||
XCTAssertNil(pastFailure)
|
||||
}
|
||||
|
||||
func test_given_a_buffered_bounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled() async {
|
||||
func
|
||||
test_given_a_buffered_bounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled()
|
||||
async
|
||||
{
|
||||
// Given
|
||||
let buffered = Indefinite(value: 1).async.buffer(policy: .bounded(3))
|
||||
|
||||
|
||||
@@ -15,16 +15,16 @@ import AsyncAlgorithms
|
||||
final class TestBufferedByteIterator: XCTestCase {
|
||||
actor Isolated<T: Sendable> {
|
||||
var value: T
|
||||
|
||||
|
||||
init(_ value: T) {
|
||||
self.value = value
|
||||
}
|
||||
|
||||
|
||||
func update(_ value: T) async {
|
||||
self.value = value
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_immediately_empty() async throws {
|
||||
let reloaded = Isolated(false)
|
||||
var iterator = AsyncBufferedByteIterator(capacity: 3) { buffer in
|
||||
@@ -39,7 +39,7 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
wasReloaded = await reloaded.value
|
||||
XCTAssertTrue(wasReloaded)
|
||||
}
|
||||
|
||||
|
||||
func test_one_pass() async throws {
|
||||
let reloaded = Isolated(0)
|
||||
var iterator = AsyncBufferedByteIterator(capacity: 3) { buffer in
|
||||
@@ -52,7 +52,7 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
buffer.copyBytes(from: [1, 2, 3])
|
||||
return 3
|
||||
}
|
||||
|
||||
|
||||
var reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, 0)
|
||||
var byte = try await iterator.next()
|
||||
@@ -76,7 +76,7 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, 2)
|
||||
}
|
||||
|
||||
|
||||
func test_three_pass() async throws {
|
||||
let reloaded = Isolated(0)
|
||||
var iterator = AsyncBufferedByteIterator(capacity: 3) { buffer in
|
||||
@@ -89,10 +89,10 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
buffer.copyBytes(from: [1, 2, 3])
|
||||
return 3
|
||||
}
|
||||
|
||||
|
||||
var reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, 0)
|
||||
|
||||
|
||||
for n in 1...3 {
|
||||
var byte = try await iterator.next()
|
||||
XCTAssertEqual(byte, 1)
|
||||
@@ -107,8 +107,7 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, n)
|
||||
}
|
||||
|
||||
|
||||
|
||||
var byte = try await iterator.next()
|
||||
XCTAssertNil(byte)
|
||||
reloadCount = await reloaded.value
|
||||
@@ -118,7 +117,7 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, 4)
|
||||
}
|
||||
|
||||
|
||||
func test_three_pass_throwing() async throws {
|
||||
let reloaded = Isolated(0)
|
||||
var iterator = AsyncBufferedByteIterator(capacity: 3) { buffer in
|
||||
@@ -134,10 +133,10 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
buffer.copyBytes(from: [1, 2, 3])
|
||||
return 3
|
||||
}
|
||||
|
||||
|
||||
var reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, 0)
|
||||
|
||||
|
||||
for n in 1...3 {
|
||||
do {
|
||||
var byte = try await iterator.next()
|
||||
@@ -156,10 +155,9 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
XCTAssertEqual(n, 3)
|
||||
break
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
var byte = try await iterator.next()
|
||||
XCTAssertNil(byte)
|
||||
reloadCount = await reloaded.value
|
||||
@@ -169,11 +167,11 @@ final class TestBufferedByteIterator: XCTestCase {
|
||||
reloadCount = await reloaded.value
|
||||
XCTAssertEqual(reloadCount, 3)
|
||||
}
|
||||
|
||||
|
||||
func test_cancellation() async {
|
||||
struct RepeatingBytes: AsyncSequence {
|
||||
typealias Element = UInt8
|
||||
|
||||
|
||||
func makeAsyncIterator() -> AsyncBufferedByteIterator {
|
||||
AsyncBufferedByteIterator(capacity: 3) { buffer in
|
||||
buffer.copyBytes(from: [1, 2, 3])
|
||||
|
||||
@@ -29,7 +29,7 @@ final class TestChain2: XCTestCase {
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain2_outputs_elements_from_first_sequence_and_throws_when_first_throws() async throws {
|
||||
let chained = chain([1, 2, 3].async.map { try throwOn(3, $0) }, [4, 5, 6].async)
|
||||
var iterator = chained.makeAsyncIterator()
|
||||
@@ -48,7 +48,7 @@ final class TestChain2: XCTestCase {
|
||||
let pastEnd = try await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain2_outputs_elements_from_sequences_and_throws_when_second_throws() async throws {
|
||||
let chained = chain([1, 2, 3].async, [4, 5, 6].async.map { try throwOn(5, $0) })
|
||||
var iterator = chained.makeAsyncIterator()
|
||||
@@ -67,7 +67,7 @@ final class TestChain2: XCTestCase {
|
||||
let pastEnd = try await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain2_finishes_when_task_is_cancelled() async {
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
@@ -115,7 +115,7 @@ final class TestChain3: XCTestCase {
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain3_outputs_elements_from_first_sequence_and_throws_when_first_throws() async throws {
|
||||
let chained = chain([1, 2, 3].async.map { try throwOn(3, $0) }, [4, 5, 6].async, [7, 8, 9].async)
|
||||
var iterator = chained.makeAsyncIterator()
|
||||
@@ -134,7 +134,7 @@ final class TestChain3: XCTestCase {
|
||||
let pastEnd = try await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain3_outputs_elements_from_sequences_and_throws_when_second_throws() async throws {
|
||||
let chained = chain([1, 2, 3].async, [4, 5, 6].async.map { try throwOn(5, $0) }, [7, 8, 9].async)
|
||||
var iterator = chained.makeAsyncIterator()
|
||||
@@ -153,7 +153,7 @@ final class TestChain3: XCTestCase {
|
||||
let pastEnd = try await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain3_outputs_elements_from_sequences_and_throws_when_third_throws() async throws {
|
||||
let chained = chain([1, 2, 3].async, [4, 5, 6].async, [7, 8, 9].async.map { try throwOn(8, $0) })
|
||||
var iterator = chained.makeAsyncIterator()
|
||||
@@ -172,7 +172,7 @@ final class TestChain3: XCTestCase {
|
||||
let pastEnd = try await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_chain3_finishes_when_task_is_cancelled() async {
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
|
||||
@@ -123,7 +123,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_time_equalChunks() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"ABC- DEF- GHI- |"
|
||||
$0.inputs[0].chunked(by: .repeating(every: .steps(4), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -132,7 +134,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_time_unequalChunks() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"AB------ A------- ABCDEFG- |"
|
||||
$0.inputs[0].chunked(by: .repeating(every: .steps(8), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -141,7 +145,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_time_emptyChunks() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"-- 1- --|"
|
||||
$0.inputs[0].chunked(by: .repeating(every: .steps(2), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -150,7 +156,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_time_error() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"AB^"
|
||||
$0.inputs[0].chunked(by: .repeating(every: .steps(5), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -159,7 +167,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_time_unsignaledTrailingChunk() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"111-111|"
|
||||
$0.inputs[0].chunked(by: .repeating(every: .steps(4), clock: $0.clock)).map(sumCharacters)
|
||||
@@ -168,7 +178,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_timeAndCount_timeAlwaysPrevails() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"AB------ A------- ABCDEFG- |"
|
||||
$0.inputs[0].chunks(ofCount: 42, or: .repeating(every: .steps(8), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -177,7 +189,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_timeAndCount_countAlwaysPrevails() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"AB --A-B -|"
|
||||
$0.inputs[0].chunks(ofCount: 2, or: .repeating(every: .steps(8), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -186,7 +200,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_timeAndCount_countResetsAfterCount() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"ABCDE --- ABCDE |"
|
||||
$0.inputs[0].chunks(ofCount: 5, or: .repeating(every: .steps(8), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -195,7 +211,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_timeAndCount_countResetsAfterSignal() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"AB------ ABCDE |"
|
||||
$0.inputs[0].chunks(ofCount: 5, or: .repeating(every: .steps(8), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -204,7 +222,9 @@ final class TestChunk: XCTestCase {
|
||||
}
|
||||
|
||||
func test_timeAndCount_error() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"ABC^"
|
||||
$0.inputs[0].chunks(ofCount: 5, or: .repeating(every: .steps(8), clock: $0.clock)).map(concatCharacters)
|
||||
@@ -279,7 +299,9 @@ final class TestChunk: XCTestCase {
|
||||
func test_projection() {
|
||||
validate {
|
||||
"A'Aa''ab' b'BB''bb' 'cc''CC' |"
|
||||
$0.inputs[0].chunked(on: { $0.first!.lowercased() }).map { concatCharacters($0.1.map( {String($0.first!)} ) ) }
|
||||
$0.inputs[0].chunked(on: { $0.first!.lowercased() }).map {
|
||||
concatCharacters($0.1.map({ String($0.first!) }))
|
||||
}
|
||||
"-- - 'AAa' - - 'bBb' - ['cC'|]"
|
||||
}
|
||||
}
|
||||
@@ -287,7 +309,9 @@ final class TestChunk: XCTestCase {
|
||||
func test_projection_singleValue() {
|
||||
validate {
|
||||
"A----|"
|
||||
$0.inputs[0].chunked(on: { $0.first!.lowercased() }).map { concatCharacters($0.1.map( {String($0.first!)} ) ) }
|
||||
$0.inputs[0].chunked(on: { $0.first!.lowercased() }).map {
|
||||
concatCharacters($0.1.map({ String($0.first!) }))
|
||||
}
|
||||
"-----[A|]"
|
||||
}
|
||||
}
|
||||
@@ -295,7 +319,7 @@ final class TestChunk: XCTestCase {
|
||||
func test_projection_singleGroup() {
|
||||
validate {
|
||||
"ABCDE|"
|
||||
$0.inputs[0].chunked(on: { _ in 42 }).map { concatCharacters($0.1.map( {String($0.first!)} ) ) }
|
||||
$0.inputs[0].chunked(on: { _ in 42 }).map { concatCharacters($0.1.map({ String($0.first!) })) }
|
||||
"-----['ABCDE'|]"
|
||||
}
|
||||
}
|
||||
@@ -303,7 +327,9 @@ final class TestChunk: XCTestCase {
|
||||
func test_projection_error() {
|
||||
validate {
|
||||
"Aa^"
|
||||
$0.inputs[0].chunked(on: { $0.first!.lowercased() }).map { concatCharacters($0.1.map( {String($0.first!)} ) ) }
|
||||
$0.inputs[0].chunked(on: { $0.first!.lowercased() }).map {
|
||||
concatCharacters($0.1.map({ String($0.first!) }))
|
||||
}
|
||||
"--^"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,7 +20,7 @@ final class TestCombineLatest2: XCTestCase {
|
||||
let actual = await Array(sequence)
|
||||
XCTAssertGreaterThanOrEqual(actual.count, 3)
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_combineLatest1() async {
|
||||
let a = [1, 2, 3]
|
||||
let b = ["a", "b", "c"]
|
||||
@@ -33,7 +33,7 @@ final class TestCombineLatest2: XCTestCase {
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_combineLatest2() async {
|
||||
let a = [1, 2, 3]
|
||||
let b = ["a", "b", "c"]
|
||||
@@ -46,7 +46,7 @@ final class TestCombineLatest2: XCTestCase {
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_ordering1() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -64,31 +64,31 @@ final class TestCombineLatest2: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (2, "b")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (2, "b"), (3, "b")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (2, "b"), (3, "b"), (3, "c")])
|
||||
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (2, "b"), (3, "b"), (3, "c")])
|
||||
}
|
||||
|
||||
|
||||
func test_ordering2() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -106,31 +106,31 @@ final class TestCombineLatest2: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (2, "b")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (2, "b"), (2, "c")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c")])
|
||||
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c")])
|
||||
}
|
||||
|
||||
|
||||
func test_ordering3() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -148,31 +148,31 @@ final class TestCombineLatest2: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (3, "a")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (3, "a"), (3, "b")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (3, "a"), (3, "b"), (3, "c")])
|
||||
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a"), (3, "a"), (3, "b"), (3, "c")])
|
||||
}
|
||||
|
||||
|
||||
func test_ordering4() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -190,31 +190,31 @@ final class TestCombineLatest2: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (1, "c")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (1, "c"), (2, "c")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (1, "c"), (2, "c"), (3, "c")])
|
||||
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b"), (1, "c"), (2, "c"), (3, "c")])
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_ordering1() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -236,25 +236,25 @@ final class TestCombineLatest2: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b")])
|
||||
|
||||
|
||||
XCTAssertEqual(validator.failure as? Failure, Failure())
|
||||
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a"), (1, "b")])
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_ordering2() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -276,25 +276,25 @@ final class TestCombineLatest2: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a")])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a")])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a")])
|
||||
|
||||
|
||||
XCTAssertEqual(validator.failure as? Failure, Failure())
|
||||
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a"), (2, "a")])
|
||||
}
|
||||
|
||||
|
||||
func test_cancellation() async {
|
||||
let source1 = Indefinite(value: "test1")
|
||||
let source2 = Indefinite(value: "test2")
|
||||
@@ -319,15 +319,15 @@ final class TestCombineLatest2: XCTestCase {
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_combineLatest_when_cancelled() async {
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
let c2 = Indefinite(value: "test1").async
|
||||
for await _ in combineLatest(c1, c2) {}
|
||||
}
|
||||
t.cancel()
|
||||
func test_combineLatest_when_cancelled() async {
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
let c2 = Indefinite(value: "test1").async
|
||||
for await _ in combineLatest(c1, c2) {}
|
||||
}
|
||||
t.cancel()
|
||||
}
|
||||
}
|
||||
|
||||
final class TestCombineLatest3: XCTestCase {
|
||||
@@ -339,7 +339,7 @@ final class TestCombineLatest3: XCTestCase {
|
||||
let actual = await Array(sequence)
|
||||
XCTAssertGreaterThanOrEqual(actual.count, 3)
|
||||
}
|
||||
|
||||
|
||||
func test_ordering1() async {
|
||||
var a = GatedSequence([1, 2, 3])
|
||||
var b = GatedSequence(["a", "b", "c"])
|
||||
@@ -361,36 +361,42 @@ final class TestCombineLatest3: XCTestCase {
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [])
|
||||
c.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4)])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4)])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4), (2, "b", 4)])
|
||||
c.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5)])
|
||||
a.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5), (3, "b", 5)])
|
||||
b.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5), (3, "b", 5), (3, "c", 5)])
|
||||
c.advance()
|
||||
|
||||
|
||||
value = await validator.validate()
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5), (3, "b", 5), (3, "c", 5), (3, "c", 6)])
|
||||
XCTAssertEqual(
|
||||
value,
|
||||
[(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5), (3, "b", 5), (3, "c", 5), (3, "c", 6)]
|
||||
)
|
||||
|
||||
await fulfillment(of: [finished], timeout: 1.0)
|
||||
value = validator.current
|
||||
XCTAssertEqual(value, [(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5), (3, "b", 5), (3, "c", 5), (3, "c", 6)])
|
||||
XCTAssertEqual(
|
||||
value,
|
||||
[(1, "a", 4), (2, "a", 4), (2, "b", 4), (2, "b", 5), (3, "b", 5), (3, "c", 5), (3, "c", 6)]
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -23,7 +23,7 @@ final class TestCompacted: XCTestCase {
|
||||
}
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
|
||||
|
||||
func test_compacted_produces_nil_next_element_when_iteration_is_finished() async {
|
||||
let source = [1, 2, nil, 3, 4, nil, 5]
|
||||
let expected = source.compactMap { $0 }
|
||||
@@ -37,7 +37,7 @@ final class TestCompacted: XCTestCase {
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_compacted_is_equivalent_to_compactMap_when_input_as_no_nil_elements() async {
|
||||
let source: [Int?] = [1, 2, 3, 4, 5]
|
||||
let expected = source.compactMap { $0 }
|
||||
@@ -48,7 +48,7 @@ final class TestCompacted: XCTestCase {
|
||||
}
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
|
||||
|
||||
func test_compacted_throws_when_root_sequence_throws() async throws {
|
||||
let sequence = [1, nil, 3, 4, 5, nil, 7].async.map { try throwOn(4, $0) }.compacted()
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
@@ -65,7 +65,7 @@ final class TestCompacted: XCTestCase {
|
||||
let pastEnd = try await iterator.next()
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
|
||||
func test_compacted_finishes_when_iteration_task_is_cancelled() async {
|
||||
let value: String? = "test"
|
||||
let source = Indefinite(value: value)
|
||||
|
||||
@@ -14,7 +14,9 @@ import AsyncAlgorithms
|
||||
|
||||
final class TestDebounce: XCTestCase {
|
||||
func test_delayingValues() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"abcd----e---f-g----|"
|
||||
$0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
|
||||
@@ -23,7 +25,9 @@ final class TestDebounce: XCTestCase {
|
||||
}
|
||||
|
||||
func test_delayingValues_dangling_last() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"abcd----e---f-g-|"
|
||||
$0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
|
||||
@@ -31,27 +35,32 @@ final class TestDebounce: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_finishDoesntDebounce() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"a|"
|
||||
$0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
|
||||
"-[a|]"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_throwDoesntDebounce() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"a^"
|
||||
$0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
|
||||
"-^"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_noValues() throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
validate {
|
||||
"----|"
|
||||
$0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
|
||||
@@ -59,24 +68,28 @@ final class TestDebounce: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func test_Rethrows() async throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
|
||||
let debounce = [1].async.debounce(for: .zero, clock: ContinuousClock())
|
||||
for await _ in debounce {}
|
||||
|
||||
let throwingDebounce = [1].async.map { try throwOn(2, $0) }.debounce(for: .zero, clock: ContinuousClock())
|
||||
for try await _ in throwingDebounce {}
|
||||
func test_Rethrows() async throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
|
||||
func test_debounce_when_cancelled() async throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
let debounce = [1].async.debounce(for: .zero, clock: ContinuousClock())
|
||||
for await _ in debounce {}
|
||||
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
for await _ in c1.debounce(for: .seconds(1), clock: .continuous) {}
|
||||
}
|
||||
t.cancel()
|
||||
let throwingDebounce = [1].async.map { try throwOn(2, $0) }.debounce(for: .zero, clock: ContinuousClock())
|
||||
for try await _ in throwingDebounce {}
|
||||
}
|
||||
|
||||
func test_debounce_when_cancelled() async throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else {
|
||||
throw XCTSkip("Skipped due to Clock/Instant/Duration availability")
|
||||
}
|
||||
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
for await _ in c1.debounce(for: .seconds(1), clock: .continuous) {}
|
||||
}
|
||||
t.cancel()
|
||||
}
|
||||
}
|
||||
@@ -19,7 +19,7 @@ final class TestDictionary: XCTestCase {
|
||||
let actual = await Dictionary(uniqueKeysWithValues: source.async)
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_uniqueKeysAndValues() async {
|
||||
let source = Array([1, 2, 3, 4, 5, 6])
|
||||
let input = source.async.map { (value: Int) async throws -> (Int, Int) in
|
||||
@@ -33,14 +33,14 @@ final class TestDictionary: XCTestCase {
|
||||
XCTAssertEqual((error as NSError).code, -1)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_uniquingWith() async {
|
||||
let source = [("a", 1), ("b", 2), ("a", 3), ("b", 4)]
|
||||
let expected = Dictionary(source) { first, _ in first }
|
||||
let actual = await Dictionary(source.async) { first, _ in first }
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_uniquingWith() async {
|
||||
let source = Array([1, 2, 3, 4, 5, 6])
|
||||
let input = source.async.map { (value: Int) async throws -> (Int, Int) in
|
||||
@@ -54,16 +54,16 @@ final class TestDictionary: XCTestCase {
|
||||
XCTAssertEqual((error as NSError).code, -1)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func test_grouping() async {
|
||||
let source = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"]
|
||||
let expected = Dictionary(grouping: source, by: { $0.first! })
|
||||
let actual = await Dictionary(grouping: source.async, by: { $0.first! })
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
|
||||
|
||||
func test_throwing_grouping() async {
|
||||
let source = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"]
|
||||
let source = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"]
|
||||
let input = source.async.map { (value: String) async throws -> String in
|
||||
if value == "Kweku" { throw NSError(domain: NSCocoaErrorDomain, code: -1, userInfo: nil) }
|
||||
return value
|
||||
|
||||
@@ -13,8 +13,10 @@ import XCTest
|
||||
import AsyncAlgorithms
|
||||
|
||||
extension Sequence where Element: Sequence, Element.Element: Equatable & Sendable {
|
||||
func nestedAsync(throwsOn bad: Element.Element) -> AsyncSyncSequence<[AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>]> {
|
||||
let array: [AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>] = self.map { $0.async }.map {
|
||||
func nestedAsync(
|
||||
throwsOn bad: Element.Element
|
||||
) -> AsyncSyncSequence<[AsyncThrowingMapSequence<AsyncSyncSequence<Element>, Element.Element>]> {
|
||||
let array: [AsyncThrowingMapSequence<AsyncSyncSequence<Element>, Element.Element>] = self.map { $0.async }.map {
|
||||
$0.map { try throwOn(bad, $0) }
|
||||
}
|
||||
return array.async
|
||||
@@ -22,7 +24,7 @@ extension Sequence where Element: Sequence, Element.Element: Equatable & Sendabl
|
||||
}
|
||||
|
||||
extension Sequence where Element: Sequence, Element.Element: Sendable {
|
||||
var nestedAsync : AsyncSyncSequence<[AsyncSyncSequence<Element>]> {
|
||||
var nestedAsync: AsyncSyncSequence<[AsyncSyncSequence<Element>]> {
|
||||
return self.map { $0.async }.async
|
||||
}
|
||||
}
|
||||
@@ -105,7 +107,7 @@ final class TestJoinedBySeparator: XCTestCase {
|
||||
}
|
||||
|
||||
func test_cancellation() async {
|
||||
let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let source: AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let sequence = source.joined(separator: ["past indefinite"].async)
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
@@ -189,7 +191,7 @@ final class TestJoined: XCTestCase {
|
||||
}
|
||||
|
||||
func test_cancellation() async {
|
||||
let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let source: AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let sequence = source.joined()
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
|
||||
Loaded 100 of 118 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user