@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/Combine/Publishers/Publishers.Sequence.swift

@@ -0,0 +1,437 @@
+//
+//  Publishers.Sequence.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 19.06.2019.
+//
+
+extension Publishers {
+
+    /// A publisher that publishes a given sequence of elements.
+    ///
+    /// When the publisher exhausts the elements in the sequence, the next request
+    /// causes the publisher to finish.
+    public struct Sequence<Elements: Swift.Sequence, Failure: Error>: Publisher {
+
+        public typealias Output = Elements.Element
+
+        /// The sequence of elements to publish.
+        public let sequence: Elements
+
+        /// Creates a publisher for a sequence of elements.
+        ///
+        /// - Parameter sequence: The sequence of elements to publish.
+        public init(sequence: Elements) {
+            self.sequence = sequence
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Failure == Downstream.Failure,
+                  Elements.Element == Downstream.Input
+        {
+            let inner = Inner(downstream: subscriber, sequence: sequence)
+            if inner.isExhausted {
+                subscriber.receive(subscription: Subscriptions.empty)
+                subscriber.receive(completion: .finished)
+                inner.cancel()
+            } else {
+                subscriber.receive(subscription: inner)
+            }
+        }
+    }
+}
+
+extension Publishers.Sequence {
+
+    private final class Inner<Downstream: Subscriber, Elements: Sequence, Failure>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Elements.Element,
+              Downstream.Failure == Failure
+    {
+
+        typealias Iterator = Elements.Iterator
+        typealias Element = Elements.Element
+
+        private var sequence: Elements?
+        private var downstream: Downstream?
+        private var iterator: Iterator
+        private var next: Element?
+        private var pendingDemand = Subscribers.Demand.none
+        private var recursion = false
+        private var lock = UnfairLock.allocate()
+
+        fileprivate init(downstream: Downstream, sequence: Elements) {
+            self.sequence = sequence
+            self.downstream = downstream
+            self.iterator = sequence.makeIterator()
+            next = iterator.next()
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        fileprivate var isExhausted: Bool {
+            return next == nil
+        }
+
+        var description: String {
+            return sequence.map(String.init(describing:)) ?? "Sequence"
+        }
+
+        var customMirror: Mirror {
+            let children =
+                CollectionOfOne<Mirror.Child>(("sequence", sequence ?? [Element]()))
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard downstream != nil else {
+                lock.unlock()
+                return
+            }
+            pendingDemand += demand
+            if recursion {
+                lock.unlock()
+                return
+            }
+
+            while let downstream = self.downstream, pendingDemand > 0 {
+                if let current = self.next {
+                    pendingDemand -= 1
+
+                    // Combine calls next() while the lock is held.
+                    // It is possible to engineer a custom Sequence that would cause
+                    // a deadlock here, but it would be something insane.
+                    let next = iterator.next()
+                    recursion = true
+                    lock.unlock()
+                    let additionalDemand = downstream.receive(current)
+                    lock.lock()
+                    recursion = false
+                    pendingDemand += additionalDemand
+                    self.next = next
+                }
+
+                if next == nil {
+                    self.downstream = nil
+                    self.sequence = nil
+                    lock.unlock()
+                    downstream.receive(completion: .finished)
+                    return
+                }
+            }
+
+            lock.unlock()
+        }
+
+        func cancel() {
+            lock.lock()
+            downstream = nil
+            sequence = nil
+            lock.unlock()
+        }
+    }
+}
+
+extension Publishers.Sequence: Equatable where Elements: Equatable {}
+
+extension Publishers.Sequence where Failure == Never {
+
+    public func min(
+        by areInIncreasingOrder: (Elements.Element, Elements.Element) -> Bool
+    ) -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.min(by: areInIncreasingOrder))
+    }
+
+    public func max(
+        by areInIncreasingOrder: (Elements.Element, Elements.Element) -> Bool
+    ) -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.max(by: areInIncreasingOrder))
+    }
+
+    public func first(
+        where predicate: (Elements.Element) -> Bool
+    ) -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.first(where: predicate))
+    }
+}
+
+extension Publishers.Sequence {
+
+    public func allSatisfy(
+        _ predicate: (Elements.Element) -> Bool
+    ) -> Result<Bool, Failure>.OCombine.Publisher {
+        return .init(sequence.allSatisfy(predicate))
+    }
+
+    public func tryAllSatisfy(
+        _ predicate: (Elements.Element) throws -> Bool
+    ) -> Result<Bool, Error>.OCombine.Publisher {
+        return .init(Result { try sequence.allSatisfy(predicate) })
+    }
+
+    public func collect() -> Result<[Elements.Element], Failure>.OCombine.Publisher {
+        return .init(Array(sequence))
+    }
+
+    public func compactMap<ElementOfResult>(
+        _ transform: (Elements.Element) -> ElementOfResult?
+    ) -> Publishers.Sequence<[ElementOfResult], Failure> {
+        return .init(sequence: sequence.compactMap(transform))
+    }
+
+    public func contains(
+        where predicate: (Elements.Element) -> Bool
+    ) -> Result<Bool, Failure>.OCombine.Publisher {
+        return .init(sequence.contains(where: predicate))
+    }
+
+    public func tryContains(
+        where predicate: (Elements.Element) throws -> Bool
+    ) -> Result<Bool, Error>.OCombine.Publisher {
+        return .init(Result { try sequence.contains(where: predicate) })
+    }
+
+    public func drop(
+        while predicate: (Elements.Element) -> Bool
+    ) -> Publishers.Sequence<DropWhileSequence<Elements>, Failure> {
+        return .init(sequence: sequence.drop(while: predicate))
+    }
+
+    public func dropFirst(
+        _ count: Int = 1
+    ) -> Publishers.Sequence<DropFirstSequence<Elements>, Failure> {
+        return .init(sequence: sequence.dropFirst(count))
+    }
+
+    public func filter(
+        _ isIncluded: (Elements.Element) -> Bool
+    ) -> Publishers.Sequence<[Elements.Element], Failure> {
+        return .init(sequence: sequence.filter(isIncluded))
+    }
+
+    public func ignoreOutput() -> Empty<Elements.Element, Failure> {
+        return .init()
+    }
+
+    public func map<ElementOfResult>(
+        _ transform: (Elements.Element) -> ElementOfResult
+    ) -> Publishers.Sequence<[ElementOfResult], Failure> {
+        return .init(sequence: sequence.map(transform))
+    }
+
+    public func prefix(
+        _ maxLength: Int
+    ) -> Publishers.Sequence<PrefixSequence<Elements>, Failure> {
+        return .init(sequence: sequence.prefix(maxLength))
+    }
+
+    public func prefix(
+        while predicate: (Elements.Element) -> Bool
+    ) -> Publishers.Sequence<[Elements.Element], Failure> {
+        return .init(sequence: sequence.prefix(while: predicate))
+    }
+
+    public func reduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: @escaping (Accumulator, Elements.Element) -> Accumulator
+    ) -> Result<Accumulator, Failure>.OCombine.Publisher {
+        return .init(sequence.reduce(initialResult, nextPartialResult))
+    }
+
+    public func tryReduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult:
+            @escaping (Accumulator, Elements.Element) throws -> Accumulator
+    ) -> Result<Accumulator, Error>.OCombine.Publisher {
+        return .init(Result { try sequence.reduce(initialResult, nextPartialResult) })
+    }
+
+    public func replaceNil<ElementOfResult>(
+        with output: ElementOfResult
+    ) -> Publishers.Sequence<[Elements.Element], Failure>
+        where Elements.Element == ElementOfResult?
+    {
+        return .init(sequence: sequence.map { $0 ?? output })
+    }
+
+    public func scan<ElementOfResult>(
+        _ initialResult: ElementOfResult,
+        _ nextPartialResult:
+            @escaping (ElementOfResult, Elements.Element) -> ElementOfResult
+    ) -> Publishers.Sequence<[ElementOfResult], Failure> {
+        var accumulator = initialResult
+        return .init(sequence: sequence.map {
+            accumulator = nextPartialResult(accumulator, $0)
+            return accumulator
+        })
+    }
+
+    public func setFailureType<NewFailure: Error>(
+        to error: NewFailure.Type
+    ) -> Publishers.Sequence<Elements, NewFailure> {
+        return .init(sequence: sequence)
+    }
+}
+
+extension Publishers.Sequence where Elements.Element: Equatable {
+
+    public func removeDuplicates() -> Publishers.Sequence<[Elements.Element], Failure> {
+        var previous: Elements.Element?
+        var result = [Elements.Element]()
+        for element in sequence where element != previous {
+            result.append(element)
+            previous = element
+        }
+        return .init(sequence: result)
+    }
+
+    public func contains(
+        _ output: Elements.Element
+    ) -> Result<Bool, Failure>.OCombine.Publisher {
+        return .init(sequence.contains(output))
+    }
+}
+
+extension Publishers.Sequence where Failure == Never, Elements.Element: Comparable {
+
+    public func min() -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.min())
+    }
+
+    public func max() -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.max())
+    }
+}
+
+extension Publishers.Sequence where Elements: Collection, Failure == Never {
+
+    public func first() -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.first)
+    }
+
+    public func output(
+        at index: Elements.Index
+    ) -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.indices.contains(index) ? sequence[index] : nil)
+    }
+}
+
+extension Publishers.Sequence where Elements: Collection {
+
+    public func count() -> Result<Int, Failure>.OCombine.Publisher {
+        return .init(sequence.count)
+    }
+
+    public func output(
+        in range: Range<Elements.Index>
+    ) -> Publishers.Sequence<[Elements.Element], Failure> {
+        return .init(sequence: Array(sequence[range]))
+    }
+}
+
+extension Publishers.Sequence where Elements: BidirectionalCollection, Failure == Never {
+
+    public func last() -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.last)
+    }
+
+    public func last(
+        where predicate: (Elements.Element) -> Bool
+    ) -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.last(where: predicate))
+    }
+}
+
+extension Publishers.Sequence where Elements: RandomAccessCollection, Failure == Never {
+
+    public func output(
+        at index: Elements.Index
+    ) -> Optional<Elements.Element>.OCombine.Publisher {
+        return .init(sequence.indices.contains(index) ? sequence[index] : nil)
+    }
+
+    public func count() -> Just<Int> {
+        return .init(sequence.count)
+    }
+}
+
+extension Publishers.Sequence where Elements: RandomAccessCollection {
+
+    public func output(
+        in range: Range<Elements.Index>
+    ) -> Publishers.Sequence<[Elements.Element], Failure> {
+        return .init(sequence: Array(sequence[range]))
+    }
+
+    public func count() -> Result<Int, Failure>.OCombine.Publisher {
+        return .init(sequence.count)
+    }
+}
+
+extension Publishers.Sequence where Elements: RangeReplaceableCollection {
+
+    public func prepend(
+        _ elements: Elements.Element...
+    ) -> Publishers.Sequence<Elements, Failure> {
+        return prepend(elements)
+    }
+
+    public func prepend<OtherSequence: Sequence>(
+        _ elements: OtherSequence
+    ) -> Publishers.Sequence<Elements, Failure>
+        where OtherSequence.Element == Elements.Element
+    {
+        var result = Elements()
+        result.reserveCapacity(
+            sequence.count + elements.underestimatedCount
+        )
+        result.append(contentsOf: elements)
+        result.append(contentsOf: sequence)
+        return .init(sequence: result)
+    }
+
+    public func prepend(
+        _ publisher: Publishers.Sequence<Elements, Failure>
+    ) -> Publishers.Sequence<Elements, Failure> {
+        var result = publisher.sequence
+        result.append(contentsOf: sequence)
+        return .init(sequence: result)
+    }
+
+    public func append(
+        _ elements: Elements.Element...
+    ) -> Publishers.Sequence<Elements, Failure> {
+        return append(elements)
+    }
+
+    public func append<OtherSequence: Sequence>(
+        _ elements: OtherSequence
+    ) -> Publishers.Sequence<Elements, Failure>
+        where OtherSequence.Element == Elements.Element
+    {
+        var result = sequence
+        result.append(contentsOf: elements)
+        return .init(sequence: result)
+    }
+
+    public func append(
+        _ publisher: Publishers.Sequence<Elements, Failure>
+    ) -> Publishers.Sequence<Elements, Failure> {
+        return append(publisher.sequence)
+    }
+}
+
+extension Sequence {
+
+    public var publisher: Publishers.Sequence<Self, Never> {
+        return .init(sequence: self)
+    }
+}

package/Sources/Combine/Publishers/Publishers.SetFailureType.swift

@@ -0,0 +1,120 @@
+//
+//  Publishers.SetFailureType.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 08.07.2019.
+//
+
+extension Publishers {
+
+    /// A publisher that appears to send a specified failure type.
+    ///
+    /// The publisher cannot actually fail with the specified type and instead
+    /// just finishes normally. Use this publisher type when you need to match
+    /// the error types for two mismatched publishers.
+    public struct SetFailureType<Upstream: Publisher, Failure: Error>: Publisher
+        where Upstream.Failure == Never
+    {
+        public typealias Output = Upstream.Output
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// Creates a publisher that appears to send a specified failure type.
+        ///
+        /// - 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.Failure == Failure, Downstream.Input == Output
+        {
+            upstream.subscribe(Inner(downstream: subscriber))
+        }
+
+        public func setFailureType<NewFailure: Error>(
+            to failure: NewFailure.Type
+        ) -> Publishers.SetFailureType<Upstream, NewFailure> {
+            return .init(upstream: upstream)
+        }
+    }
+}
+
+extension Publishers.SetFailureType: Equatable where Upstream: Equatable {}
+
+extension Publisher where Failure == Never {
+
+    /// Changes the failure type declared by the upstream publisher.
+    ///
+    /// Use `setFailureType(to:)` when you need set the error type of a publisher that
+    /// cannot fail.
+    ///
+    /// Conversely, if the upstream can fail, you would use `mapError(_:)` to provide
+    /// instructions on converting the error types to needed by the downstream publisher’s
+    /// inputs.
+    ///
+    /// The following example has two publishers with mismatched error types: `pub1`’s
+    /// error type is `Never`, and `pub2`’s error type is `Error`. Because of
+    /// the mismatch, the `combineLatest(_:)` operator requires that `pub1` use
+    /// `setFailureType(to:)` to make it appear that `pub1` can produce the `Error` type,
+    /// like `pub2` can.
+    ///
+    ///     let pub1 = [0, 1, 2, 3, 4, 5].publisher
+    ///     let pub2 = CurrentValueSubject<Int, Error>(0)
+    ///     let cancellable = pub1
+    ///         .setFailureType(to: Error.self)
+    ///         .combineLatest(pub2)
+    ///         .sink(
+    ///             receiveCompletion: { print ("completed: \($0)") },
+    ///             receiveValue: { print ("value: \($0)")}
+    ///          )
+    ///
+    ///     // Prints: "value: (5, 0)".
+    ///
+    /// - Parameter failureType: The `Failure` type presented by this publisher.
+    /// - Returns: A publisher that appears to send the specified failure type.
+    public func setFailureType<NewFailure: Error>(
+        to failureType: NewFailure.Type
+    ) -> Publishers.SetFailureType<Self, NewFailure> {
+        return .init(upstream: self)
+    }
+}
+
+extension Publishers.SetFailureType {
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Upstream.Output == Downstream.Input, Failure == Downstream.Failure
+    {
+        private let downstream: Downstream
+        let combineIdentifier = CombineIdentifier()
+
+        fileprivate init(downstream: Downstream) {
+            self.downstream = downstream
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Never>) {
+            downstream.receive(completion: .finished)
+        }
+
+        var description: String { return "SetFailureType" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publishers/Publishers.Share.swift

@@ -0,0 +1,104 @@
+//
+//  Publishers.Share
+//  
+//
+//  Created by Sergej Jaskiewicz on 18/09/2019.
+//
+
+extension Publisher {
+
+    /// Shares the output of an upstream publisher with multiple subscribers.
+    ///
+    /// The publisher returned by this operator supports multiple subscribers, all of whom
+    /// receive unchanged elements and completion states from the upstream publisher.
+    ///
+    ///  - Tip: `Publishers.Share` is effectively a combination of
+    ///  the `Publishers.Multicast` and `PassthroughSubject` publishers, with an implicit
+    ///  `autoconnect()`.
+    ///
+    /// The following example uses a sequence publisher as a counter to publish three
+    /// random numbers, generated by a `map(_:)` operator. It uses a `share()` operator
+    /// to share the same random number to each of two subscribers. This example uses
+    /// a `delay(for:tolerance:scheduler:options:)` operator only to prevent the first
+    /// subscriber from exhausting the sequence publisher immediately; an asynchronous
+    /// publisher wouldn’t need this.
+    ///
+    ///     let pub = (1...3).publisher
+    ///         .delay(for: 1, scheduler: DispatchQueue.main)
+    ///         .map( { _ in return Int.random(in: 0...100) } )
+    ///         .print("Random")
+    ///         .share()
+    ///
+    ///     cancellable1 = pub
+    ///         .sink { print ("Stream 1 received: \($0)")}
+    ///     cancellable2 = pub
+    ///         .sink { print ("Stream 2 received: \($0)")}
+    ///
+    ///     // Prints:
+    ///     // Random: receive value: (20)
+    ///     // Stream 1 received: 20
+    ///     // Stream 2 received: 20
+    ///     // Random: receive value: (85)
+    ///     // Stream 1 received: 85
+    ///     // Stream 2 received: 85
+    ///     // Random: receive value: (98)
+    ///     // Stream 1 received: 98
+    ///     // Stream 2 received: 98
+    ///
+    /// Without the `share()` operator, stream 1 receives three random values,
+    /// followed by stream 2 receiving three different random values.
+    ///
+    /// Also note that `Publishers.Share` is a `class` rather than a `struct` like most
+    /// other publishers. This means you can use this operator to create a publisher
+    /// instance that uses reference semantics.
+    ///
+    /// - Returns: A class instance that shares elements received from its upstream to
+    ///   multiple subscribers.
+    public func share() -> Publishers.Share<Self> {
+        return .init(upstream: self)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that shares the output of an upstream publisher with multiple
+    /// subscribers.
+    ///
+    /// This publisher type supports multiple subscribers, all of whom receive unchanged
+    /// elements and completion states from the upstream publisher.
+    ///
+    ///  - Tip: `Publishers.Share` is effectively a combination of
+    ///  the `Publishers.Multicast` and `PassthroughSubject` publishers,
+    ///  with an implicit `autoconnect()`.
+    ///
+    /// Also note that `Publishers.Share` is a `class` rather than a `struct` like most
+    /// other publishers. Use this type when you need a publisher instance that uses
+    /// reference semantics.
+    public final class Share<Upstream: Publisher>: Publisher, Equatable {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        private typealias MulticastSubject = PassthroughSubject<Output, Failure>
+
+        private let inner: Autoconnect<Multicast<Upstream, MulticastSubject>>
+
+        public let upstream: Upstream
+
+        public init(upstream: Upstream) {
+            self.inner = upstream.multicast(subject: .init()).autoconnect()
+            self.upstream = upstream
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            inner.subscribe(subscriber)
+        }
+
+        public static func == (lhs: Share, rhs: Share) -> Bool {
+            return lhs === rhs
+        }
+    }
+}