@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/Combine/Publishers/Publishers.SubscribeOn.swift

@@ -0,0 +1,197 @@
+//
+//  Publishers.SubscribeOn.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+extension Publisher {
+
+    /// Specifies the scheduler on which to perform subscribe, cancel, and request
+    /// operations.
+    ///
+    /// In contrast with `receive(on:options:)`, which affects downstream messages,
+    /// `subscribe(on:options:)` changes the execution context of upstream messages.
+    ///
+    /// In the following example, the `subscribe(on:options:)` operator causes
+    /// `ioPerformingPublisher` to receive requests on `backgroundQueue`, while
+    /// the `receive(on:options:)` causes `uiUpdatingSubscriber` to receive elements and
+    /// completion on `RunLoop.main`.
+    ///
+    ///     let ioPerformingPublisher == // Some publisher.
+    ///     let uiUpdatingSubscriber == // Some subscriber that updates the UI.
+    ///
+    ///     ioPerformingPublisher
+    ///         .subscribe(on: backgroundQueue)
+    ///         .receive(on: RunLoop.main)
+    ///         .subscribe(uiUpdatingSubscriber)
+    ///
+    ///
+    /// Using `subscribe(on:options:)` also causes the upstream publisher to perform
+    /// `cancel()` using the specfied scheduler.
+    ///
+    /// - Parameters:
+    ///   - scheduler: The scheduler used to send messages to upstream publishers.
+    ///   - options: Options that customize the delivery of elements.
+    /// - Returns: A publisher which performs upstream operations on the specified
+    ///   scheduler.
+    public func subscribe<Context: Scheduler>(
+        on scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.SubscribeOn<Self, Context> {
+        return .init(upstream: self, scheduler: scheduler, options: options)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that receives elements from an upstream publisher on a specific
+    /// scheduler.
+    public struct SubscribeOn<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The scheduler the publisher should use to receive elements.
+        public let scheduler: Context
+
+        /// Scheduler options that customize the delivery of elements.
+        public let options: Context.SchedulerOptions?
+
+        public init(upstream: Upstream,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions?) {
+            self.upstream = upstream
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            let inner = Inner(scheduler: scheduler,
+                              options: options,
+                              downstream: subscriber)
+            scheduler.schedule(options: options) {
+                self.upstream.subscribe(inner)
+            }
+        }
+    }
+}
+
+extension Publishers.SubscribeOn {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let lock = UnfairLock.allocate()
+        private let downstream: Downstream
+        private let scheduler: Context
+        private let options: Context.SchedulerOptions?
+        private var state = SubscriptionStatus.awaitingSubscription
+        private let upstreamLock = UnfairLock.allocate()
+
+        init(scheduler: Context,
+             options: Context.SchedulerOptions?,
+             downstream: Downstream) {
+            self.downstream = downstream
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        deinit {
+            lock.deallocate()
+            upstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case .subscribed = state else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case .subscribed = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            scheduler.schedule(options: options) {
+                self.scheduledRequest(demand, subscription: subscription)
+            }
+        }
+
+        private func scheduledRequest(_ demand: Subscribers.Demand,
+                                      subscription: Subscription) {
+            upstreamLock.lock()
+            subscription.request(demand)
+            upstreamLock.unlock()
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            scheduler.schedule(options: options) {
+                self.scheduledCancel(subscription)
+            }
+        }
+
+        private func scheduledCancel(_ subscription: Subscription) {
+            upstreamLock.lock()
+            subscription.cancel()
+            upstreamLock.unlock()
+        }
+
+        var description: String { return "SubscribeOn" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publishers/Publishers.SwitchToLatest.swift

@@ -0,0 +1,444 @@
+//
+//  Publishers.SwitchToLatest.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 07.01.2020.
+//
+
+extension Publisher where Output: Publisher, Output.Failure == Failure {
+
+    /// Republishes elements sent by the most recently received publisher.
+    ///
+    /// This operator works with an upstream publisher of publishers, flattening
+    /// the stream of elements to appear as if they were coming from a single stream of
+    /// elements. It switches the inner publisher as new ones arrive but keeps the outer
+    /// publisher constant for downstream subscribers.
+    ///
+    /// For example, given the type `AnyPublisher<URLSession.DataTaskPublisher, NSError>`,
+    /// calling `switchToLatest()` results in the type
+    /// `SwitchToLatest<(Data, URLResponse), URLError>`.
+    /// The downstream subscriber sees a continuous stream of `(Data, URLResponse)`
+    /// elements from what looks like a single `URLSession.DataTaskPublisher` even though
+    /// the elements are coming from different upstream publishers.
+    ///
+    /// When this operator receives a new publisher from the upstream publisher, it
+    /// cancels its previous subscription. Use this feature to prevent earlier publishers
+    /// from performing unnecessary work, such as creating network request publishers from
+    /// frequently updating user interface publishers.
+    ///
+    /// The following example updates a `PassthroughSubject` with a new value every
+    /// `0.1` seconds. A `map(_:)` operator receives the new value and uses it to create
+    /// a new `URLSession.DataTaskPublisher`. By using the `switchToLatest()` operator,
+    /// the downstream sink subscriber receives the `(Data, URLResponse)` output type from
+    /// the data task publishers, rather than the `URLSession.DataTaskPublisher` type
+    /// produced by the `map(_:)` operator. Furthermore, creating each new data task
+    /// publisher cancels the previous data task publisher.
+    ///
+    ///     let subject = PassthroughSubject<Int, Never>()
+    ///     cancellable = subject
+    ///         .setFailureType(to: URLError.self)
+    ///         .map() { index -> URLSession.DataTaskPublisher in
+    ///             let url = URL(string: "https://example.org/get?index=\(index)")!
+    ///             return URLSession.shared.dataTaskPublisher(for: url)
+    ///         }
+    ///         .switchToLatest()
+    ///         .sink(receiveCompletion: { print("Complete: \($0)") },
+    ///               receiveValue: { (data, response) in
+    ///                 guard let url = response.url else {
+    ///                     print("Bad response.")
+    ///                     return
+    ///                 }
+    ///                 print("URL: \(url)")
+    ///         })
+    ///
+    ///     for index in 1...5 {
+    ///         DispatchQueue.main.asyncAfter(deadline: .now() + TimeInterval(index/10)) {
+    ///             subject.send(index)
+    ///         }
+    ///     }
+    ///
+    ///     // Prints "URL: https://example.org/get?index=5"
+    ///
+    /// The exact behavior of this example depends on the value of `asyncAfter` and
+    /// the speed of the network connection. If the delay value is longer, or the network
+    /// connection is fast, the earlier data tasks may complete before `switchToLatest()`
+    /// can cancel them. If this happens, the output includes multiple URLs whose tasks
+    /// complete before cancellation.
+    public func switchToLatest() -> Publishers.SwitchToLatest<Output, Self> {
+        return .init(upstream: self)
+    }
+}
+
+extension Publisher where Output: Publisher, Failure == Never {
+
+    /// Republishes elements sent by the most recently received publisher.
+    ///
+    /// This operator works with an upstream publisher of publishers, flattening
+    /// the stream of elements to appear as if they were coming from a single stream of
+    /// elements. It switches the inner publisher as new ones arrive but keeps the outer
+    /// publisher constant for downstream subscribers.
+    ///
+    /// When this operator receives a new publisher from the upstream publisher, it
+    /// cancels its previous subscription. Use this feature to prevent earlier publishers
+    /// from performing unnecessary work, such as creating network request publishers from
+    /// frequently updating user interface publishers.
+    public func switchToLatest() -> Publishers.SwitchToLatest<
+        Output, Publishers.SetFailureType<Self, Output.Failure>
+    > {
+        return setFailureType(to: Output.Failure.self).switchToLatest()
+    }
+}
+
+extension Publisher where Output: Publisher, Failure == Never, Output.Failure == Never {
+
+    /// Republishes elements sent by the most recently received publisher.
+    ///
+    /// This operator works with an upstream publisher of publishers, flattening
+    /// the stream of elements to appear as if they were coming from a single stream of
+    /// elements. It switches the inner publisher as new ones arrive but keeps the outer
+    /// publisher constant for downstream subscribers.
+    ///
+    /// When this operator receives a new publisher from the upstream publisher, it
+    /// cancels its previous subscription. Use this feature to prevent earlier publishers
+    /// from performing unnecessary work, such as creating network request publishers from
+    /// frequently updating user interface publishers.
+    public func switchToLatest() -> Publishers.SwitchToLatest<Output, Self> {
+        return .init(upstream: self)
+    }
+}
+
+extension Publisher where Output: Publisher, Output.Failure == Never {
+
+    /// Republishes elements sent by the most recently received publisher.
+    ///
+    /// This operator works with an upstream publisher of publishers, flattening
+    /// the stream of elements to appear as if they were coming from a single stream of
+    /// elements. It switches the inner publisher as new ones arrive but keeps the outer
+    /// publisher constant for downstream subscribers.
+    ///
+    /// When this operator receives a new publisher from the upstream publisher, it
+    /// cancels its previous subscription. Use this feature to prevent earlier publishers
+    /// from performing unnecessary work, such as creating network request publishers from
+    /// frequently updating user interface publishers.
+    public func switchToLatest() -> Publishers.SwitchToLatest<
+        Publishers.SetFailureType<Output, Failure>,
+        Publishers.Map<Self, Publishers.SetFailureType<Output, Failure>>
+    > {
+        return map { $0.setFailureType(to: Failure.self) }.switchToLatest()
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that flattens nested publishers.
+    ///
+    /// Given a publisher that publishes `Publisher` instances,
+    /// the `Publishers.SwitchToLatest` publisher produces a sequence of events from only
+    /// the most recent one. For example, given the type
+    /// `AnyPublisher<URLSession.DataTaskPublisher, NSError>`, calling `switchToLatest()`
+    /// results in the type `SwitchToLatest<(Data, URLResponse), URLError>`.
+    /// The downstream subscriber sees a continuous stream of `(Data, URLResponse)`
+    /// elements from what looks like a single `URLSession.DataTaskPublisher` even though
+    /// the elements are coming from different upstream publishers.
+    ///
+    /// When `Publishers.SwitchToLatest` receives a new publisher from the upstream
+    /// publisher, it cancels its previous subscription. Use this feature to prevent
+    /// earlier publishers from performing unnecessary work, such as creating network
+    /// request publishers from frequently-updating user interface publishers.
+    public struct SwitchToLatest<NestedPublisher: Publisher, Upstream: Publisher>
+        : Publisher
+        where Upstream.Output == NestedPublisher,
+              Upstream.Failure == NestedPublisher.Failure
+    {
+        public typealias Output = NestedPublisher.Output
+
+        public typealias Failure = NestedPublisher.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// Creates a publisher that “flattens” nested publishers.
+        ///
+        /// - Parameter upstream: The publisher from which this publisher receives
+        ///   elements.
+        public init(upstream: Upstream) {
+            self.upstream = upstream
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            let outer = Outer(downstream: subscriber)
+            subscriber.receive(subscription: outer)
+            upstream.subscribe(outer)
+        }
+    }
+}
+
+extension Publishers.SwitchToLatest {
+    fileprivate final class Outer<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == NestedPublisher.Output,
+              Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+        private var outerSubscription: Subscription?
+        private var currentInnerSubscription: Subscription?
+        private var currentInnerIndex: UInt64 = 0
+        private var nextInnerIndex: UInt64 = 1
+        private let lock = UnfairLock.allocate()
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+        private var cancelled = false
+        private var finished = false
+        private var sentCompletion = false
+        private var awaitingInnerSubscription = false
+        private var downstreamDemand = Subscribers.Demand.none
+
+        init(downstream: Downstream) {
+            self.downstream = downstream
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard outerSubscription == nil && !cancelled else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            outerSubscription = subscription
+            lock.unlock()
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            if cancelled || finished {
+                lock.unlock()
+                return .none
+            }
+
+            if let currentInnerSubscription = self.currentInnerSubscription.take()  {
+                lock.unlock()
+                currentInnerSubscription.cancel()
+                lock.lock()
+            }
+
+            let index = nextInnerIndex
+            currentInnerIndex = index
+            nextInnerIndex += 1
+            awaitingInnerSubscription = true
+            lock.unlock()
+            input.subscribe(Side(inner: self, index: index))
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            outerSubscription = nil
+            finished = true
+
+            if cancelled {
+                lock.unlock()
+                return
+            }
+
+            switch completion {
+            case .finished:
+                if awaitingInnerSubscription {
+                    lock.unlock()
+                    return
+                }
+                if currentInnerSubscription == nil {
+                    sentCompletion = true
+                    lock.unlock()
+                    downstreamLock.lock()
+                    downstream.receive(completion: completion)
+                    downstreamLock.unlock()
+                } else {
+                    lock.unlock()
+                }
+            case .failure:
+                let currentInnerSubscription = self.currentInnerSubscription.take()
+                sentCompletion = true
+                lock.unlock()
+                currentInnerSubscription?.cancel()
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+            }
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            downstreamDemand += demand
+            if let currentInnerSubscription = self.currentInnerSubscription {
+                lock.unlock()
+                currentInnerSubscription.request(demand)
+            } else {
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            cancelled = true
+            let currentInnerSubscription = self.currentInnerSubscription.take()
+            let outerSubscription = self.outerSubscription.take()
+            lock.unlock()
+
+            currentInnerSubscription?.cancel()
+            outerSubscription?.cancel()
+        }
+
+        var description: String { return "SwitchToLatest" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+
+        private func receiveInner(subscription: Subscription, _ index: UInt64) {
+            lock.lock()
+            guard currentInnerIndex == index &&
+                  !cancelled &&
+                  currentInnerSubscription == nil else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+
+            currentInnerSubscription = subscription
+            awaitingInnerSubscription = false
+            let downstreamDemand = self.downstreamDemand
+            lock.unlock()
+            if downstreamDemand > 0 {
+                subscription.request(downstreamDemand)
+            }
+        }
+
+        private func receiveInner(_ input: NestedPublisher.Output,
+                                  _ index: UInt64) -> Subscribers.Demand {
+            lock.lock()
+            guard currentInnerIndex == index && !cancelled else {
+                lock.unlock()
+                return .none
+            }
+
+            // This will crash if we don't have any demand yet.
+            // Combine crashes here too.
+            downstreamDemand -= 1
+
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            if newDemand > 0 {
+                lock.lock()
+                downstreamDemand += newDemand
+                lock.unlock()
+            }
+
+            return newDemand
+        }
+
+        private func receiveInner(completion: Subscribers.Completion<Failure>,
+                                  _ index: UInt64) {
+            lock.lock()
+            guard currentInnerIndex == index && !cancelled else {
+                lock.unlock()
+                return
+            }
+            precondition(!awaitingInnerSubscription, "Unexpected completion")
+            currentInnerSubscription = nil
+            switch completion {
+            case .finished:
+                if sentCompletion || !finished {
+                    lock.unlock()
+                    return
+                }
+                sentCompletion = true
+                lock.unlock()
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+            case .failure:
+                if sentCompletion {
+                    lock.unlock()
+                    return
+                }
+                cancelled = true
+                let outerSubscription = self.outerSubscription.take()
+                sentCompletion = true
+                lock.unlock()
+                outerSubscription?.cancel()
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+            }
+        }
+    }
+}
+
+extension Publishers.SwitchToLatest.Outer {
+    private struct Side
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+    {
+        typealias Input = NestedPublisher.Output
+
+        typealias Failure = NestedPublisher.Failure
+
+        typealias Outer =
+            Publishers.SwitchToLatest<NestedPublisher, Upstream>.Outer<Downstream>
+
+        private let index: UInt64
+        private let outer: Outer
+
+        let combineIdentifier = CombineIdentifier()
+
+        init(inner: Outer, index: UInt64) {
+            self.index = index
+            self.outer = inner
+        }
+
+        func receive(subscription: Subscription) {
+            outer.receiveInner(subscription: subscription, index)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            return outer.receiveInner(input, index)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            outer.receiveInner(completion: completion, index)
+        }
+
+        var description: String { return "SwitchToLatest" }
+
+        var customMirror: Mirror {
+            let children = CollectionOfOne<Mirror.Child>(
+                ("parentSubscription", outer.combineIdentifier)
+            )
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}