Files
swift-mirror/stdlib/public/Concurrency/AsyncThrowingCompactMapSequence.swift
Philippe Hausler 8578584f61 Implementations for operators and async functions on AsyncSequence per SE-0298 (#35740)
* Implementations for operators and async functions on AsyncSequence per SE-0298

* Add trailing new lines to AsyncSequence adopter files

* Remove extra // from preambles

* Transition sequence properties and sequence initializers to internal

* Rename Upstream to Base

* Rename "Failable" asynchronous sequences to "Throwing"

* Make iteration consistent with closure lifetimes and track failure via state

* Use for await syntax for async function extensions on AsyncSequence

* Work-around rethrows calculations being incorrect for conformance + closure rethrowing

* Update testing names to reflect Throwing versus Failable

* Incorperate runAsyncAndBlock into the test function for suite calls

* Remove @frozen from AsyncSequence operators

* Back out reduce family functions for now due to IRGen bug

* Additional corrections for throwing cases and fix up potential linux crasher

* Add a upstream and throwing tests and correct flatMap's throwing behavior

* Unify parameter names to count

* Add a more helpful precondition on prefix

* Add tests for throwing cases of non closure async functions on AsyncSequence

* Correct missing count transition in dropFirst

* Correct missing , in assertion

* [NFC] add commentary on optimization in dropFirst on dropFirst

* Disable collect tests for non macOS platforms for now

* Disable all async sequence tests for non macOS platforms for now
2021-02-12 14:43:59 -08:00

91 lines
2.5 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 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
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import Swift
extension AsyncSequence {
@inlinable
public __consuming func compactMap<ElementOfResult>(
_ transform: @escaping (Element) async throws -> ElementOfResult?
) -> AsyncThrowingCompactMapSequence<Self, ElementOfResult> {
return AsyncThrowingCompactMapSequence(self, transform: transform)
}
}
public struct AsyncThrowingCompactMapSequence<Base: AsyncSequence, ElementOfResult> {
@usableFromInline
let base: Base
@usableFromInline
let transform: (Base.Element) async throws -> ElementOfResult?
@usableFromInline
init(
_ base: Base,
transform: @escaping (Base.Element) async throws -> ElementOfResult?
) {
self.base = base
self.transform = transform
}
}
extension AsyncThrowingCompactMapSequence: AsyncSequence {
public typealias Element = ElementOfResult
public typealias AsyncIterator = Iterator
public struct Iterator: AsyncIteratorProtocol {
public typealias Element = ElementOfResult
@usableFromInline
var baseIterator: Base.AsyncIterator
@usableFromInline
let transform: (Base.Element) async throws -> ElementOfResult?
@usableFromInline
var finished = false
@usableFromInline
init(
_ baseIterator: Base.AsyncIterator,
transform: @escaping (Base.Element) async throws -> ElementOfResult?
) {
self.baseIterator = baseIterator
self.transform = transform
}
@inlinable
public mutating func next() async throws -> ElementOfResult? {
while !finished {
guard let element = try await baseIterator.next() else {
finished = true
return nil
}
do {
if let transformed = try await transform(element) {
return transformed
}
} catch {
finished = true
throw error
}
}
return nil
}
}
@inlinable
public __consuming func makeAsyncIterator() -> Iterator {
return Iterator(base.makeAsyncIterator(), transform: transform)
}
}