|
| 1 | +// |
| 2 | +// CompactScan.swift |
| 3 | +// CombineExt |
| 4 | +// |
| 5 | +// Created by Thibault Wittemberg on 04/09/2021. |
| 6 | +// Copyright © 2021 Combine Community. All rights reserved. |
| 7 | +// |
| 8 | + |
| 9 | +#if canImport(Combine) |
| 10 | +import Combine |
| 11 | + |
| 12 | +@available(OSX 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) |
| 13 | +public extension Publisher { |
| 14 | + /// Transforms elements from the upstream publisher by providing the current |
| 15 | + /// element to a closure along with the last value returned by the closure. |
| 16 | + /// |
| 17 | + /// The ``nextPartialResult`` closure might return nil values. In that case the accumulator won't change until the next non-nil upstream publisher value. |
| 18 | + /// |
| 19 | + /// Use ``Publisher/compactScan(_:_:)`` to accumulate all previously-published values into a single |
| 20 | + /// value, which you then combine with each newly-published value. |
| 21 | + /// |
| 22 | + /// The following example logs a running total of all values received |
| 23 | + /// from the sequence publisher. |
| 24 | + /// |
| 25 | + /// let range = (0...5) |
| 26 | + /// let cancellable = range.publisher |
| 27 | + /// .compactScan(0) { |
| 28 | + /// guard $1.isMultiple(of: 2) else { return nil } |
| 29 | + /// return $0 + $1 |
| 30 | + /// } |
| 31 | + /// .sink { print ("\($0)", terminator: " ") } |
| 32 | + /// // Prints: "0 2 6 ". |
| 33 | + /// |
| 34 | + /// - Parameters: |
| 35 | + /// - initialResult: The previous result returned by the `nextPartialResult` closure. |
| 36 | + /// - nextPartialResult: A closure that takes as its arguments the previous value returned by the closure and the next element emitted from the upstream publisher. |
| 37 | + /// - Returns: A publisher that transforms elements by applying a closure that receives its previous return value and the next element from the upstream publisher. |
| 38 | + func compactScan<T>(_ initialResult: T, _ nextPartialResult: @escaping (T, Output) -> T?) -> AnyPublisher<T, Failure> { |
| 39 | + self.scan((initialResult, initialResult)) { accumulator, value -> (T, T?) in |
| 40 | + let lastNonNilAccumulator = accumulator.0 |
| 41 | + let newAccumulator = nextPartialResult(lastNonNilAccumulator, value) |
| 42 | + return (newAccumulator ?? lastNonNilAccumulator, newAccumulator) |
| 43 | + } |
| 44 | + .compactMap { $0.1 } |
| 45 | + .eraseToAnyPublisher() |
| 46 | + } |
| 47 | + |
| 48 | + /// Transforms elements from the upstream publisher by providing the current element to an error-throwing closure along with the last value returned by the closure. |
| 49 | + /// |
| 50 | + /// The ``nextPartialResult`` closure might return nil values. In that case the accumulator won't change until the next non-nil upstream publisher value. |
| 51 | + /// |
| 52 | + /// Use ``Publisher/tryCompactScan(_:_:)`` to accumulate all previously-published values into a single value, which you then combine with each newly-published value. |
| 53 | + /// If your accumulator closure throws an error, the publisher terminates with the error. |
| 54 | + /// |
| 55 | + /// In the example below, ``Publisher/tryCompactScan(_:_:)`` calls a division function on elements of a collection publisher. The resulting publisher publishes each result until the function encounters a `DivisionByZeroError`, which terminates the publisher. |
| 56 | + /// |
| 57 | + /// struct DivisionByZeroError: Error {} |
| 58 | + /// |
| 59 | + /// /// A function that throws a DivisionByZeroError if `current` provided by the TryScan publisher is zero. |
| 60 | + /// func myThrowingFunction(_ lastValue: Int, _ currentValue: Int) throws -> Int? { |
| 61 | + /// guard currentValue.isMultiple(of: 2) else { return nil } |
| 62 | + /// guard currentValue != 0 else { throw DivisionByZeroError() } |
| 63 | + /// return lastValue / currentValue |
| 64 | + /// } |
| 65 | + /// |
| 66 | + /// let numbers = [1, 2, 3, 4, 5, 0, 6, 7, 8, 9] |
| 67 | + /// let cancellable = numbers.publisher |
| 68 | + /// .tryCompactScan(10) { try myThrowingFunction($0, $1) } |
| 69 | + /// .sink( |
| 70 | + /// receiveCompletion: { print ("\($0)") }, |
| 71 | + /// receiveValue: { print ("\($0)", terminator: " ") } |
| 72 | + /// ) |
| 73 | + /// |
| 74 | + /// // Prints: "6 2 failure(DivisionByZeroError())". |
| 75 | + /// |
| 76 | + /// If the closure throws an error, the publisher fails with the error. |
| 77 | + /// |
| 78 | + /// - Parameters: |
| 79 | + /// - initialResult: The previous result returned by the `nextPartialResult` closure. |
| 80 | + /// - nextPartialResult: An error-throwing closure that takes as its arguments the previous value returned by the closure and the next element emitted from the upstream publisher. |
| 81 | + /// - Returns: A publisher that transforms elements by applying a closure that receives its previous return value and the next element from the upstream publisher. |
| 82 | + func tryCompactScan<T>(_ initialResult: T, _ nextPartialResult: @escaping (T, Output) throws -> T?) -> AnyPublisher<T, Error> { |
| 83 | + self.tryScan((initialResult, initialResult)) { accumulator, value -> (T, T?) in |
| 84 | + let lastNonNilAccumulator = accumulator.0 |
| 85 | + let newAccumulator = try nextPartialResult(lastNonNilAccumulator, value) |
| 86 | + return (newAccumulator ?? lastNonNilAccumulator, newAccumulator) |
| 87 | + } |
| 88 | + .compactMap { $0.1 } |
| 89 | + .eraseToAnyPublisher() |
| 90 | + } |
| 91 | +} |
| 92 | +#endif |
0 commit comments