@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/Combine/Publishers/Optional.Publisher.swift

@@ -0,0 +1,315 @@
+//
+//  Optional.Publisher.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 17.06.2019.
+//
+
+extension Optional {
+
+    /// A namespace for disambiguation when both OpenCombine and Combine are imported.
+    ///
+    /// Combine extends `Optional` with a nested type `Publisher`.
+    /// If you import both OpenCombine and Combine (either explicitly or implicitly,
+    /// e. g. when importing Foundation), you will not be able to write
+    /// `Optional<Int>.Publisher`, because Swift is unable to understand
+    /// which `Publisher` you're referring to.
+    ///
+    /// So you have to write `Optional<Int>.OCombine.Publisher`.
+    ///
+    /// This bug is tracked [here](https://bugs.swift.org/browse/SR-11183).
+    ///
+    /// You can omit this whenever Combine is not available (e. g. on Linux).
+    public struct OCombine {
+
+        fileprivate let optional: Optional
+
+        fileprivate init(_ optional: Optional) {
+            self.optional = optional
+        }
+
+        public var publisher: Publisher {
+            return Publisher(optional)
+        }
+
+        /// The type of a Combine publisher that publishes the value of a Swift optional
+        /// instance to each subscriber exactly once, if the instance has any value at
+        /// all.
+        ///
+        /// In contrast with the `Just` publisher, which always produces a single value,
+        /// this publisher might not send any values and instead finish normally,
+        /// if `output` is `nil`.
+        public struct Publisher: Combine.Publisher {
+
+            /// The kind of value published by this publisher.
+            ///
+            /// This publisher produces the type wrapped by the optional.
+            public typealias Output = Wrapped
+
+            /// The kind of error this publisher might publish.
+            ///
+            /// The optional publisher never produces errors.
+            public typealias Failure = Never
+
+            /// The output to deliver to each subscriber.
+            public let output: Wrapped?
+
+            /// Creates a publisher to emit the value of the optional, or to finish
+            /// immediately if the optional doesn't have a value.
+            ///
+            /// - Parameter output: The result to deliver to each subscriber.
+            public init(_ output: Output?) {
+                self.output = output
+            }
+
+            /// Implements the Publisher protocol by accepting the subscriber and
+            /// immediately publishing the optional’s value if it has one, or finishing
+            /// normally if it doesn’t.
+            ///
+            /// - Parameter subscriber: The subscriber to add.
+            public func receive<Downstream: Subscriber>(subscriber: Downstream)
+                where Output == Downstream.Input, Failure == Downstream.Failure
+            {
+                if let output = output {
+                    subscriber.receive(subscription: Inner(value: output,
+                                                           downstream: subscriber))
+                } else {
+                    subscriber.receive(subscription: Subscriptions.empty)
+                    subscriber.receive(completion: .finished)
+                }
+            }
+        }
+    }
+
+    public var ocombine: OCombine {
+        return .init(self)
+    }
+
+#if !canImport(Combine)
+    /// The type of a Combine publisher that publishes the value of a Swift optional
+    /// instance to each subscriber exactly once, if the instance has any value at
+    /// all.
+    ///
+    /// In contrast with the `Just` publisher, which always produces a single value,
+    /// this publisher might not send any values and instead finish normally,
+    /// if `output` is `nil`.
+    public typealias Publisher = OCombine.Publisher
+
+    public var publisher: Publisher {
+        return Publisher(self)
+    }
+#endif
+}
+
+extension Optional.OCombine {
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Wrapped
+    {
+        // NOTE: this class has been audited for thread safety.
+        // Combine doesn't use any locking here.
+
+        private var downstream: Downstream?
+        private let output: Wrapped
+
+        init(value: Wrapped, downstream: Downstream) {
+            self.output = value
+            self.downstream = downstream
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            guard let downstream = self.downstream.take() else { return }
+            _ = downstream.receive(output)
+            downstream.receive(completion: .finished)
+        }
+
+        func cancel() {
+            downstream = nil
+        }
+
+        var description: String { return "Optional" }
+
+        var customMirror: Mirror {
+            return Mirror(self, unlabeledChildren: CollectionOfOne(output))
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Optional.OCombine.Publisher: Equatable where Wrapped: Equatable {}
+
+extension Optional.OCombine.Publisher where Wrapped: Equatable {
+
+    public func contains(_ output: Output) -> Optional<Bool>.OCombine.Publisher {
+        return .init(self.output.map { $0 == output })
+    }
+
+    public func removeDuplicates() -> Optional<Wrapped>.OCombine.Publisher {
+        return self
+    }
+}
+
+extension Optional.OCombine.Publisher where Wrapped: Comparable {
+
+    public func min() -> Optional<Wrapped>.OCombine.Publisher {
+        return self
+    }
+
+    public func max() -> Optional<Wrapped>.OCombine.Publisher {
+        return self
+    }
+}
+
+extension Optional.OCombine.Publisher {
+
+    public func allSatisfy(
+        _ predicate: (Output) -> Bool
+    ) -> Optional<Bool>.OCombine.Publisher {
+        return .init(self.output.map(predicate))
+    }
+
+    public func collect() -> Optional<[Output]>.OCombine.Publisher {
+        return .init(self.output.map { [$0] } ?? [])
+    }
+
+    public func compactMap<ElementOfResult>(
+        _ transform: (Output) -> ElementOfResult?
+    ) -> Optional<ElementOfResult>.OCombine.Publisher {
+        return .init(self.output.flatMap(transform))
+    }
+
+    public func min(
+        by areInIncreasingOrder: (Output, Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+
+    public func max(
+        by areInIncreasingOrder: (Output, Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+
+    public func contains(
+        where predicate: (Output) -> Bool
+    ) -> Optional<Bool>.OCombine.Publisher {
+        return .init(self.output.map(predicate))
+    }
+
+    public func count() -> Optional<Int>.OCombine.Publisher {
+        return .init(self.output.map { _ in 1 })
+    }
+
+    public func dropFirst(_ count: Int = 1) -> Optional<Output>.OCombine.Publisher {
+        precondition(count >= 0, "count must not be negative")
+        return .init(self.output.flatMap { count == 0 ? $0 : nil })
+    }
+
+    public func drop(
+        while predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(self.output.flatMap { predicate($0) ? nil : $0 })
+    }
+
+    public func first() -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+
+    public func first(
+        where predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(output.flatMap { predicate($0) ? $0 : nil })
+    }
+
+    public func last() -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+
+    public func last(
+        where predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(output.flatMap { predicate($0) ? $0 : nil })
+    }
+
+    public func filter(
+        _ isIncluded: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(output.flatMap { isIncluded($0) ? $0 : nil })
+    }
+
+    public func ignoreOutput() -> Empty<Output, Failure> {
+        return .init()
+    }
+
+    public func map<ElementOfResult>(
+        _ transform: (Output) -> ElementOfResult
+    ) -> Optional<ElementOfResult>.OCombine.Publisher {
+        return .init(output.map(transform))
+    }
+
+    public func output(at index: Int) -> Optional<Output>.OCombine.Publisher {
+        precondition(index >= 0, "index must not be negative")
+        return .init(output.flatMap { index == 0 ? $0 : nil })
+    }
+
+    public func output<RangeExpression: Swift.RangeExpression>(
+        in range: RangeExpression
+    ) -> Optional<Output>.OCombine.Publisher where RangeExpression.Bound == Int {
+        let range = range.relative(to: 0 ..< Int.max)
+        precondition(range.lowerBound >= 0, "lowerBound must not be negative")
+
+        // I don't know why, but Combine has this precondition
+        precondition(range.upperBound < .max - 1)
+        return .init(
+            output.flatMap { (range.lowerBound == 0 && range.upperBound != 0) ? $0 : nil }
+        )
+    }
+
+    public func prefix(_ maxLength: Int) -> Optional<Output>.OCombine.Publisher {
+        precondition(maxLength >= 0, "maxLength must not be negative")
+        return .init(output.flatMap { maxLength > 0 ? $0 : nil })
+    }
+
+    public func prefix(
+        while predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(output.flatMap { predicate($0) ? $0 : nil })
+    }
+
+    public func reduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: (Accumulator, Output) -> Accumulator
+    ) -> Optional<Accumulator>.OCombine.Publisher {
+        return .init(output.map { nextPartialResult(initialResult, $0) })
+    }
+
+    public func scan<ElementOfResult>(
+        _ initialResult: ElementOfResult,
+        _ nextPartialResult: (ElementOfResult, Output) -> ElementOfResult
+    ) -> Optional<ElementOfResult>.OCombine.Publisher {
+        return .init(output.map { nextPartialResult(initialResult, $0) })
+    }
+
+    public func removeDuplicates(
+        by predicate: (Output, Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+
+    public func replaceError(with output: Output) -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+
+    public func replaceEmpty(with output: Output) -> Just<Output> {
+        return .init(self.output ?? output)
+    }
+
+    public func retry(_ times: Int) -> Optional<Output>.OCombine.Publisher {
+        return self
+    }
+}

package/Sources/Combine/Publishers/Publishers.AllSatisfy.swift

@@ -0,0 +1,217 @@
+//
+//  Publishers.AllSatisfy.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 09.10.2019.
+//
+
+extension Publisher {
+
+    /// Publishes a single Boolean value that indicates whether all received elements pass
+    /// a given predicate.
+    ///
+    /// Use the `allSatisfy(_:)` operator to determine if all elements in a stream satisfy
+    /// a criteria you provide. When this publisher receives an element, it runs
+    /// the predicate against the element. If the predicate returns `false`, the publisher
+    /// produces a `false` value and finishes. If the upstream publisher finishes
+    /// normally, this publisher produces a `true` value and finishes.
+    ///
+    /// In the example below, the `allSatisfy(_:)` operator tests if each an integer array
+    /// publisher’s elements fall into the `targetRange`:
+    ///
+    ///     let targetRange = (-1...100)
+    ///     let numbers = [-1, 0, 10, 5]
+    ///     numbers.publisher
+    ///         .allSatisfy { targetRange.contains($0) }
+    ///         .sink { print("\($0)") }
+    ///
+    ///     // Prints: "true"
+    ///
+    /// With operators similar to `reduce(_:_:)`, this publisher produces at most one
+    /// value.
+    ///
+    ///  > Note: Upon receiving any request greater than zero, this publisher requests
+    ///  unlimited elements from the upstream publisher.
+    ///
+    /// - Parameter predicate: A closure that evaluates each received element.
+    ///   Return `true` to continue, or `false` to cancel the upstream and complete.
+    /// - Returns: A publisher that publishes a Boolean value that indicates whether
+    ///   all received elements pass a given predicate.
+    public func allSatisfy(
+        _ predicate: @escaping (Output) -> Bool
+    ) -> Publishers.AllSatisfy<Self> {
+        return .init(upstream: self, predicate: predicate)
+    }
+
+    /// Publishes a single Boolean value that indicates whether all received elements pass
+    /// a given error-throwing predicate.
+    ///
+    /// Use the `tryAllSatisfy(_:)` operator to determine if all elements in a stream
+    /// satisfy a criteria in an error-throwing predicate you provide. When this publisher
+    /// receives an element, it runs the predicate against the element. If the predicate
+    /// returns `false`, the publisher produces a `false` value and finishes.
+    /// If the upstream publisher finishes normally, this publisher produces a `true`
+    /// value and finishes. If the predicate throws an error, the publisher fails and
+    /// passes the error to its downstream subscriber.
+    ///
+    /// In the example below, an error-throwing predicate tests if each of an integer
+    /// array publisher’s elements fall into the `targetRange`; the predicate throws
+    /// an error if an element is zero and terminates the stream.
+    ///
+    ///     let targetRange = (-1...100)
+    ///     let numbers = [-1, 10, 5, 0]
+    ///
+    ///     numbers.publisher
+    ///         .tryAllSatisfy { anInt in
+    ///             guard anInt != 0 else { throw RangeError() }
+    ///             return targetRange.contains(anInt)
+    ///         }
+    ///         .sink(
+    ///             receiveCompletion: { print ("completion: \($0)") },
+    ///             receiveValue: { print ("value: \($0)") }
+    ///         )
+    ///
+    ///     // Prints: "completion: failure(RangeError())"
+    ///
+    /// With operators similar to `reduce(_:_:)`, this publisher produces at most one
+    /// value.
+    ///
+    ///  > Note: Upon receiving any request greater than zero, this publisher requests
+    ///  unlimited elements from the upstream publisher.
+    ///
+    /// - Parameter predicate: A closure that evaluates each received element. Return
+    ///   `true` to continue, or `false` to cancel the upstream and complete. The closure
+    ///   may throw an error, in which case the publisher cancels the upstream publisher
+    ///   and fails with the thrown error.
+    /// - Returns: A publisher that publishes a Boolean value that indicates whether all
+    ///   received elements pass a given predicate.
+    public func tryAllSatisfy(
+        _ predicate: @escaping (Output) throws -> Bool
+    ) -> Publishers.TryAllSatisfy<Self> {
+        return .init(upstream: self, predicate: predicate)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that publishes a single Boolean value that indicates whether
+    /// all received elements pass a given predicate.
+    public struct AllSatisfy<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Bool
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// A closure that evaluates each received element.
+        ///
+        ///  Return `true` to continue, or `false` to cancel the upstream and finish.
+        public let predicate: (Upstream.Output) -> Bool
+
+        public init(upstream: Upstream, predicate: @escaping (Upstream.Output) -> Bool) {
+            self.upstream = upstream
+            self.predicate = predicate
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure, Downstream.Input == Bool
+        {
+            upstream.subscribe(Inner(downstream: subscriber, predicate: predicate))
+        }
+    }
+
+    /// A publisher that publishes a single Boolean value that indicates whether
+    /// all received elements pass a given error-throwing predicate.
+    public struct TryAllSatisfy<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Bool
+
+        public typealias Failure = Error
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// A closure that evaluates each received element.
+        ///
+        /// Return `true` to continue, or `false` to cancel the upstream and complete.
+        /// The closure may throw, in which case the publisher cancels the upstream
+        /// publisher and fails with the thrown error.
+        public let predicate: (Upstream.Output) throws -> Bool
+
+        public init(upstream: Upstream,
+                    predicate: @escaping (Upstream.Output) throws -> Bool) {
+            self.upstream = upstream
+            self.predicate = predicate
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Failure == Error, Downstream.Input == Bool
+        {
+            upstream.subscribe(Inner(downstream: subscriber, predicate: predicate))
+        }
+    }
+}
+
+extension Publishers.AllSatisfy {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Bool,
+                         Upstream.Failure,
+                         (Upstream.Output) -> Bool>
+        where Downstream.Input == Output, Upstream.Failure == Downstream.Failure
+    {
+        fileprivate init(downstream: Downstream,
+                         predicate: @escaping (Upstream.Output) -> Bool) {
+            super.init(downstream: downstream, initial: true, reduce: predicate)
+        }
+
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            if !reduce(newValue) {
+                result = false
+                return .finished
+            }
+
+            return .continue
+        }
+
+        override var description: String { return "AllSatisfy" }
+    }
+}
+
+extension Publishers.TryAllSatisfy {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Bool,
+                         Upstream.Failure,
+                         (Upstream.Output) throws -> Bool>
+        where Downstream.Input == Output, Downstream.Failure == Error
+    {
+        fileprivate init(downstream: Downstream,
+                         predicate: @escaping (Upstream.Output) throws -> Bool) {
+            super.init(downstream: downstream, initial: true, reduce: predicate)
+        }
+
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            do {
+                if try !reduce(newValue) {
+                    result = false
+                    return .finished
+                }
+            } catch {
+                return .failure(error)
+            }
+
+            return .continue
+        }
+
+        override var description: String { return "TryAllSatisfy" }
+    }
+}

package/Sources/Combine/Publishers/Publishers.AssertNoFailure.swift

@@ -0,0 +1,158 @@
+//
+//  Publishers.AssertNoFailure.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.12.2019.
+//
+
+extension Publisher {
+
+    /// Raises a fatal error when its upstream publisher fails, and otherwise republishes
+    /// all received input.
+    ///
+    /// Use `assertNoFailure()` for internal integrity checks that are active during
+    /// testing. However, it is important to note that, like its Swift counterpart
+    /// `fatalError(_:)`, the `assertNoFailure()` operator asserts a fatal exception when
+    /// triggered during development and testing, _and_ in shipping versions of code.
+    ///
+    /// In the example below, a `CurrentValueSubject` publishes the initial and second
+    /// values successfully. The third value, containing a `genericSubjectError`, causes
+    /// the `assertNoFailure()` operator to assert a fatal exception stopping the process:
+    ///
+    ///     public enum SubjectError: Error {
+    ///         case genericSubjectError
+    ///     }
+    ///
+    ///     let subject = CurrentValueSubject<String, Error>("initial value")
+    ///     subject
+    ///         .assertNoFailure()
+    ///         .sink(receiveCompletion: { print ("completion: \($0)") },
+    ///               receiveValue: { print ("value: \($0).") }
+    ///         )
+    ///
+    ///     subject.send("second value")
+    ///     subject.send(completion: .failure(SubjectError.genericSubjectError))
+    ///
+    ///     // Prints:
+    ///     //  value: initial value.
+    ///     //  value: second value.
+    ///     // The process then terminates in the debugger as the assertNoFailure
+    ///     // operator catches the genericSubjectError.
+    ///
+    /// - Parameters:
+    ///   - prefix: A string used at the beginning of the fatal error message.
+    ///   - file: A filename used in the error message. This defaults to `#file`.
+    ///   - line: A line number used in the error message. This defaults to `#line`.
+    /// - Returns: A publisher that raises a fatal error when its upstream publisher
+    ///   fails.
+    public func assertNoFailure(_ prefix: String = "",
+                                file: StaticString = #file,
+                                line: UInt = #line) -> Publishers.AssertNoFailure<Self> {
+        return .init(upstream: self, prefix: prefix, file: file, line: line)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that raises a fatal error upon receiving any failure, and otherwise
+    /// republishes all received input.
+    ///
+    /// Use this function for internal integrity checks that are active during testing but
+    /// don't affect performance of shipping code.
+    public struct AssertNoFailure<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Never
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The string used at the beginning of the fatal error message.
+        public let prefix: String
+
+        /// The filename used in the error message.
+        public let file: StaticString
+
+        /// The line number used in the error message.
+        public let line: UInt
+
+        public init(upstream: Upstream, prefix: String, file: StaticString, line: UInt) {
+            self.upstream = upstream
+            self.prefix = prefix
+            self.file = file
+            self.line = line
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Never
+        {
+            upstream.subscribe(Inner(downstream: subscriber,
+                                     prefix: prefix,
+                                     file: file,
+                                     line: line))
+        }
+    }
+}
+
+extension Publishers.AssertNoFailure {
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Never
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let prefix: String
+
+        private let file: StaticString
+
+        private let line: UInt
+
+        let combineIdentifier = CombineIdentifier()
+
+        init(downstream: Downstream, prefix: String, file: StaticString, line: UInt) {
+            self.downstream = downstream
+            self.prefix = prefix
+            self.file = file
+            self.line = line
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            switch completion {
+            case .finished:
+                downstream.receive(completion: .finished)
+            case .failure(let error):
+                let prefix = self.prefix.isEmpty ? "" : self.prefix + ": "
+                fatalError("\(prefix)\(error)", file: file, line: line)
+            }
+        }
+
+        var description: String { return "AssertNoFailure" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("file", file),
+                ("line", line),
+                ("prefix", prefix)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}