@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/Combine/Publishers/GENERATED-Publishers.MapKeyPath.swift

@@ -0,0 +1,384 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃                                                                                     ┃
+// ┃                   Auto-generated from GYB template. DO NOT EDIT!                    ┃
+// ┃                                                                                     ┃
+// ┃                                                                                     ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+//
+//  Publishers.MapKeyPath.swift.gyb
+//  
+//
+//  Created by Sergej Jaskiewicz on 03/10/2019.
+//
+
+// swiftlint:disable large_tuple
+
+extension Publisher {
+    /// Publishes the value of the key path.
+    ///
+    /// In the following example, the `map(_:)` operator uses the Swift
+    /// key path syntax to access the `die` member
+    /// of the `DiceRoll` structure published by the `Just` publisher.
+    ///
+    /// The downstream sink subscriber receives only
+    /// the value of this `Int`,
+    /// not the entire `DiceRoll`.
+    ///
+    ///     struct DiceRoll {
+    ///         let die: Int
+    ///     }
+    ///
+    ///     cancellable = Just(DiceRoll(die: Int.random(in: 1...6)))
+    ///         .map(\.die)
+    ///         .sink {
+    ///             print ("Rolled: \($0)")
+    ///         }
+    ///     // Prints "Rolled: 4 (or some other random value).
+    ///
+    /// - Parameters:
+    ///    - keyPath: The key path of a property on `Output`.
+    /// - Returns: A publisher that publishes the value of the key path.
+    public func map<Result>(
+        _ keyPath: KeyPath<Output, Result>
+    ) -> Publishers.MapKeyPath<Self, Result> {
+        return .init(
+            upstream: self,
+            keyPath: keyPath
+        )
+    }
+    /// Publishes the values of two key paths as a tuple.
+    ///
+    /// In the following example, the `map(_:_:)` operator uses the Swift
+    /// key path syntax to access the `die1` and `die2` members
+    /// of the `DiceRoll` structure published by the `Just` publisher.
+    ///
+    /// The downstream sink subscriber receives only
+    /// these two values (as an `(Int, Int)` tuple),
+    /// not the entire `DiceRoll`.
+    ///
+    ///     struct DiceRoll {
+    ///         let die1: Int
+    ///         let die2: Int
+    ///     }
+    ///
+    ///     cancellable = Just(DiceRoll(die1: Int.random(in: 1...6),
+    ///                                 die2: Int.random(in: 1...6)))
+    ///         .map(\.die1, \.die2)
+    ///         .sink { values in
+    ///             print("""
+    ///             Rolled: \(values.0), \(values.1) \
+    ///             (total \(values.0 + values.1))
+    ///             """)
+    ///         }
+    ///     // Prints "Rolled: 4, 1 (total: 5)" (or other random values).
+    ///
+    /// - Parameters:
+    ///    - keyPath0: The key path of a property on `Output`.
+    ///    - keyPath1: The key path of another property on `Output`.
+    /// - Returns: A publisher that publishes the values of two key paths as a tuple.
+    public func map<Result0, Result1>(
+        _ keyPath0: KeyPath<Output, Result0>,
+        _ keyPath1: KeyPath<Output, Result1>
+    ) -> Publishers.MapKeyPath2<Self, Result0, Result1> {
+        return .init(
+            upstream: self,
+            keyPath0: keyPath0,
+            keyPath1: keyPath1
+        )
+    }
+    /// Publishes the values of three key paths as a tuple.
+    ///
+    /// In the following example, the `map(_:_:_:)` operator uses the Swift
+    /// key path syntax to access the `die1`, `die2`, and `die3` members
+    /// of the `DiceRoll` structure published by the `Just` publisher.
+    ///
+    /// The downstream sink subscriber receives only
+    /// these three values (as an `(Int, Int, Int)` tuple),
+    /// not the entire `DiceRoll`.
+    ///
+    ///     struct DiceRoll {
+    ///         let die1: Int
+    ///         let die2: Int
+    ///         let die3: Int
+    ///     }
+    ///
+    ///     cancellable = Just(DiceRoll(die1: Int.random(in: 1...6),
+    ///                                 die2: Int.random(in: 1...6),
+    ///                                 die3: Int.random(in: 1...6)))
+    ///         .map(\.die1, \.die2, \.die3)
+    ///         .sink { values in
+    ///             print("""
+    ///             Rolled: \(values.0), \(values.1), \(values.2) \
+    ///             (total \(values.0 + values.1 + values.2))
+    ///             """)
+    ///         }
+    ///     // Prints "Rolled: 3, 5, 4 (total: 12)" (or other random values).
+    ///
+    /// - Parameters:
+    ///    - keyPath0: The key path of a property on `Output`.
+    ///    - keyPath1: The key path of a second property on `Output`.
+    ///    - keyPath2: The key path of a third property on `Output`.
+    /// - Returns: A publisher that publishes the values of three key paths as a tuple.
+    public func map<Result0, Result1, Result2>(
+        _ keyPath0: KeyPath<Output, Result0>,
+        _ keyPath1: KeyPath<Output, Result1>,
+        _ keyPath2: KeyPath<Output, Result2>
+    ) -> Publishers.MapKeyPath3<Self, Result0, Result1, Result2> {
+        return .init(
+            upstream: self,
+            keyPath0: keyPath0,
+            keyPath1: keyPath1,
+            keyPath2: keyPath2
+        )
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that publishes the value of a key path.
+    public struct MapKeyPath<Upstream: Publisher, Output>: Publisher {
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The key path of a property to publish.
+        public let keyPath: KeyPath<Upstream.Output, Output>
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Failure == Downstream.Failure
+        {
+            upstream.subscribe(Inner(downstream: subscriber, parent: self))
+        }
+    }
+
+    /// A publisher that publishes the values of two key paths as a tuple.
+    public struct MapKeyPath2<Upstream: Publisher, Output0, Output1>: Publisher {
+
+        public typealias Output = (Output0, Output1)
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The key path of a property to publish.
+        public let keyPath0: KeyPath<Upstream.Output, Output0>
+
+        /// The key path of a second property to publish.
+        public let keyPath1: KeyPath<Upstream.Output, Output1>
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Failure == Downstream.Failure
+        {
+            upstream.subscribe(Inner(downstream: subscriber, parent: self))
+        }
+    }
+
+    /// A publisher that publishes the values of three key paths as a tuple.
+    public struct MapKeyPath3<Upstream: Publisher, Output0, Output1, Output2>: Publisher {
+
+        public typealias Output = (Output0, Output1, Output2)
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The key path of a property to publish.
+        public let keyPath0: KeyPath<Upstream.Output, Output0>
+
+        /// The key path of a second property to publish.
+        public let keyPath1: KeyPath<Upstream.Output, Output1>
+
+        /// The key path of a third property to publish.
+        public let keyPath2: KeyPath<Upstream.Output, Output2>
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Failure == Downstream.Failure
+        {
+            upstream.subscribe(Inner(downstream: subscriber, parent: self))
+        }
+    }
+}
+
+extension Publishers.MapKeyPath {
+
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let keyPath: KeyPath<Input, Output>
+
+        let combineIdentifier = CombineIdentifier()
+
+        fileprivate init(
+            downstream: Downstream,
+            parent: Publishers.MapKeyPath<Upstream, Output>
+        ) {
+            self.downstream = downstream
+            self.keyPath = parent.keyPath
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            let output = (
+                input[keyPath: keyPath]
+            )
+            return downstream.receive(output)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            downstream.receive(completion: completion)
+        }
+
+        var description: String { return "ValueForKey" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("keyPath", keyPath),
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Publishers.MapKeyPath2 {
+
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let keyPath0: KeyPath<Input, Output0>
+
+        private let keyPath1: KeyPath<Input, Output1>
+
+        let combineIdentifier = CombineIdentifier()
+
+        fileprivate init(
+            downstream: Downstream,
+            parent: Publishers.MapKeyPath2<Upstream, Output0, Output1>
+        ) {
+            self.downstream = downstream
+            self.keyPath0 = parent.keyPath0
+            self.keyPath1 = parent.keyPath1
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            let output = (
+                input[keyPath: keyPath0],
+                input[keyPath: keyPath1]
+            )
+            return downstream.receive(output)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            downstream.receive(completion: completion)
+        }
+
+        var description: String { return "ValueForKeys" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("keyPath0", keyPath0),
+                ("keyPath1", keyPath1),
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Publishers.MapKeyPath3 {
+
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let keyPath0: KeyPath<Input, Output0>
+
+        private let keyPath1: KeyPath<Input, Output1>
+
+        private let keyPath2: KeyPath<Input, Output2>
+
+        let combineIdentifier = CombineIdentifier()
+
+        fileprivate init(
+            downstream: Downstream,
+            parent: Publishers.MapKeyPath3<Upstream, Output0, Output1, Output2>
+        ) {
+            self.downstream = downstream
+            self.keyPath0 = parent.keyPath0
+            self.keyPath1 = parent.keyPath1
+            self.keyPath2 = parent.keyPath2
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            let output = (
+                input[keyPath: keyPath0],
+                input[keyPath: keyPath1],
+                input[keyPath: keyPath2]
+            )
+            return downstream.receive(output)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            downstream.receive(completion: completion)
+        }
+
+        var description: String { return "ValueForKeys" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("keyPath0", keyPath0),
+                ("keyPath1", keyPath1),
+                ("keyPath2", keyPath2),
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publishers/Just.swift

@@ -0,0 +1,313 @@
+//
+//  Just.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 16.06.2019.
+//
+
+/// A publisher that emits an output to each subscriber just once, and then finishes.
+///
+/// You can use a `Just` publisher to start a chain of publishers. A `Just` publisher is
+/// also useful when replacing a value with `Publishers.Catch`.
+///
+/// In contrast with `Result.Publisher`, a `Just` publisher can’t fail with an error.
+/// And unlike `Optional.Publisher`, a `Just` publisher always produces a value.
+public struct Just<Output>: Publisher {
+
+    public typealias Failure = Never
+
+    /// The one element that the publisher emits.
+    public let output: Output
+
+    /// Initializes a publisher that emits the specified output just once.
+    ///
+    /// - Parameter output: The one element that the publisher emits.
+    public init(_ output: Output) {
+        self.output = output
+    }
+
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Downstream.Input == Output, Downstream.Failure == Never
+    {
+        subscriber.receive(subscription: Inner(value: output, downstream: subscriber))
+    }
+}
+
+extension Just: Equatable where Output: Equatable {}
+
+extension Just where Output: Comparable {
+
+    public func min() -> Just<Output> {
+        return self
+    }
+
+    public func max() -> Just<Output> {
+        return self
+    }
+}
+
+extension Just where Output: Equatable {
+
+    public func contains(_ output: Output) -> Just<Bool> {
+        return .init(self.output == output)
+    }
+
+    public func removeDuplicates() -> Just<Output> {
+        return self
+    }
+}
+
+extension Just {
+
+    public func allSatisfy(_ predicate: (Output) -> Bool) -> Just<Bool> {
+        return .init(predicate(output))
+    }
+
+    public func tryAllSatisfy(
+        _ predicate: (Output) throws -> Bool
+    ) -> Result<Bool, Error>.OCombine.Publisher {
+        return .init(Result { try predicate(output) })
+    }
+
+    public func contains(where predicate: (Output) -> Bool) -> Just<Bool> {
+        return .init(predicate(output))
+    }
+
+    public func tryContains(
+        where predicate: (Output) throws -> Bool
+    ) -> Result<Bool, Error>.OCombine.Publisher {
+        return .init(Result { try predicate(output) })
+    }
+
+    public func collect() -> Just<[Output]> {
+        return .init([output])
+    }
+
+    public func min(
+        by areInIncreasingOrder: (Output, Output) -> Bool
+    ) -> Just<Output> {
+        return self
+    }
+
+    public func max(
+        by areInIncreasingOrder: (Output, Output) -> Bool
+    ) -> Just<Output> {
+        return self
+    }
+
+    public func count() -> Just<Int> {
+        return .init(1)
+    }
+
+    public func dropFirst(_ count: Int = 1) -> Optional<Output>.OCombine.Publisher {
+        precondition(count >= 0, "count must not be negative")
+        return .init(count > 0 ? nil : self.output)
+    }
+
+    public func drop(
+        while predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(predicate(output) ? nil : output)
+    }
+
+    public func first() -> Just<Output> {
+        return self
+    }
+
+    public func first(
+        where predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(predicate(output) ? output : nil)
+    }
+
+    public func last() -> Just<Output> {
+        return self
+    }
+
+    public func last(
+        where predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(predicate(output) ? output : nil)
+    }
+
+    public func ignoreOutput() -> Empty<Output, Never> {
+        return .init()
+    }
+
+    public func map<ElementOfResult>(
+        _ transform: (Output) -> ElementOfResult
+    ) -> Just<ElementOfResult> {
+        return .init(transform(output))
+    }
+
+    public func tryMap<ElementOfResult>(
+        _ transform: (Output) throws -> ElementOfResult
+    ) -> Result<ElementOfResult, Error>.OCombine.Publisher {
+        return .init(Result { try transform(output) })
+    }
+
+    public func compactMap<ElementOfResult>(
+        _ transform: (Output) -> ElementOfResult?
+    ) -> Optional<ElementOfResult>.OCombine.Publisher {
+        return .init(transform(output))
+    }
+
+    public func filter(
+        _ isIncluded: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(isIncluded(output) ? output : nil)
+    }
+
+    public func output(at index: Int) -> Optional<Output>.OCombine.Publisher {
+        precondition(index >= 0, "index must not be negative")
+        return .init(index == 0 ? output : nil)
+    }
+
+    public func output<RangeExpression: Swift.RangeExpression>(
+        in range: RangeExpression
+    ) -> Optional<Output>.OCombine.Publisher where RangeExpression.Bound == Int {
+        // TODO: Broken in Apple's Combine? (FB6169621)
+        // Empty range should result in a nil
+        let range = range.relative(to: 0..<Int.max)
+        return .init(range.lowerBound == 0 ? output : nil)
+        // The above implementation is used for compatibility.
+        //
+        // It actually probably should be just this:
+        // return .init(range.contains(0) ? output : nil)
+    }
+
+    public func prefix(_ maxLength: Int) -> Optional<Output>.OCombine.Publisher {
+        precondition(maxLength >= 0, "maxLength must not be negative")
+        return .init(maxLength > 0 ? output : nil)
+    }
+
+    public func prefix(
+        while predicate: (Output) -> Bool
+    ) -> Optional<Output>.OCombine.Publisher {
+        return .init(predicate(output) ? output : nil)
+    }
+
+    public func setFailureType<Failure: Error>(
+        to failureType: Failure.Type
+    ) -> Result<Output, Failure>.OCombine.Publisher {
+        return .init(output)
+    }
+
+    public func mapError<Failure: Error>(
+        _ transform: (Never) -> Failure
+    ) -> Result<Output, Failure>.OCombine.Publisher {
+        return .init(output)
+    }
+
+    public func removeDuplicates(
+        by predicate: (Output, Output) -> Bool
+    ) -> Just<Output> {
+        return self
+    }
+
+    public func tryRemoveDuplicates(
+        by predicate: (Output, Output) throws -> Bool
+    ) -> Result<Output, Error>.OCombine.Publisher {
+        return .init(Result { try _ = predicate(output, output); return output })
+    }
+
+    public func replaceError(with output: Output) -> Just<Output> {
+        return self
+    }
+
+    public func replaceEmpty(with output: Output) -> Just<Output> {
+        return self
+    }
+
+    public func retry(_ times: Int) -> Just<Output> {
+        return self
+    }
+
+    public func reduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: (Accumulator, Output) -> Accumulator
+    ) -> Result<Accumulator, Never>.OCombine.Publisher {
+        return .init(nextPartialResult(initialResult, output))
+    }
+
+    public func tryReduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: (Accumulator, Output) throws -> Accumulator
+    ) -> Result<Accumulator, Error>.OCombine.Publisher {
+        return .init(Result { try nextPartialResult(initialResult, output) })
+    }
+
+    public func scan<ElementOfResult>(
+        _ initialResult: ElementOfResult,
+        _ nextPartialResult: (ElementOfResult, Output) -> ElementOfResult
+    ) -> Result<ElementOfResult, Never>.OCombine.Publisher {
+        return .init(nextPartialResult(initialResult, output))
+    }
+
+    public func tryScan<ElementOfResult>(
+        _ initialResult: ElementOfResult,
+        _ nextPartialResult: (ElementOfResult, Output) throws -> ElementOfResult
+    ) -> Result<ElementOfResult, Error>.OCombine.Publisher {
+        return .init(Result { try nextPartialResult(initialResult, output) })
+    }
+
+    public func prepend(_ elements: Output...) -> Publishers.Sequence<[Output], Never> {
+        return prepend(elements)
+    }
+
+    public func prepend<Elements: Sequence>(
+        _ elements: Elements
+    ) -> Publishers.Sequence<[Output], Never> where Output == Elements.Element {
+        return .init(sequence: elements + [output])
+    }
+
+    public func append(_ elements: Output...) -> Publishers.Sequence<[Output], Never> {
+        return append(elements)
+    }
+
+    public func append<Elements: Sequence>(
+        _ elements: Elements
+    ) -> Publishers.Sequence<[Output], Never> where Output == Elements.Element {
+        return .init(sequence: [output] + elements)
+    }
+}
+
+extension Just {
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+    where Downstream.Input == Output
+    {
+        // NOTE: this class has been audited for thread safety.
+        // Combine doesn't use any locking here.
+
+        private var downstream: Downstream?
+        private let value: Output
+
+        fileprivate init(value: Output, downstream: Downstream) {
+            self.downstream = downstream
+            self.value = value
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            guard let downstream = self.downstream.take() else { return }
+            _ = downstream.receive(value)
+            downstream.receive(completion: .finished)
+        }
+
+        func cancel() {
+            downstream = nil
+        }
+
+        var description: String { return "Just" }
+
+        var customMirror: Mirror {
+            return Mirror(self, unlabeledChildren: CollectionOfOne(value))
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}