Make the initial value of combinePrevious optional.

Author: andersio

CHANGELOG.md

@@ -1,6 +1,8 @@
 # master
 *Please add new entries at the top.*
 
+1. `combinePrevious` for `Signal` and `SignalProducer` no longer requires an initial value. The first tuple would be emitted as soon as the second value is received by the operator if no initial value is given. (#445, kudos to @andersio)
+
 1. In Swift 3.2 or later, you may create `BindingTarget` for a key path of a specific object. (#440, kudos to @andersio)
 
 # 2.0.0-alpha.2

Sources/Signal.swift

@@ -1444,22 +1444,39 @@ extension Signal {
 
 	/// Forward events from `self` with history: values of the returned signal
 	/// are a tuples whose first member is the previous value and whose second member
-	/// is the current value. `initial` is supplied as the first member when `self`
-	/// sends its first value.
+	/// is the current value.
+	///
+	/// If an initial value is given, the returned `Signal` would emit tuples as soon as
+	/// the first value is received. If `initial` is nil, the returned `Signal` would not
+	/// emit any tuple until it has received at least two values.
 	///
 	/// - parameters:
-	///   - initial: A value that will be combined with the first value sent by
-	///              `self`.
+	///   - initial: An optional initial value.
 	///
 	/// - returns: A signal that sends tuples that contain previous and current
 	///            sent values of `self`.
-	public func combinePrevious(_ initial: Value) -> Signal<(Value, Value), Error> {
-		return scan((initial, initial)) { previousCombinedValues, newValue in
-			return (previousCombinedValues.1, newValue)
+	public func combinePrevious(_ initial: Value? = nil) -> Signal<(Value, Value), Error> {
+		return Signal<(Value, Value), Error> { observer in
+			var previous = initial
+
+			return self.observe { event in
+				switch event {
+				case let .value(value):
+					if let previous = previous {
+						observer.send(value: (previous, value))
+					}
+					previous = value
+				case .completed:
+					observer.sendCompleted()
+				case let .failed(error):
+					observer.send(error: error)
+				case .interrupted:
+					observer.sendInterrupted()
+				}
+			}
 		}
 	}
 
-
 	/// Combine all values from `self`, and forward only the final accumuated result.
 	///
 	/// See `scan(_:_:)` if the resulting producer needs to forward also the partial

Sources/SignalProducer.swift

@@ -978,18 +978,20 @@ extension SignalProducer {
 		return liftRight(Signal.skip(until:))(trigger.producer)
 	}
 
-	/// Forward events from `self` with history: values of the returned producer
-	/// are a tuple whose first member is the previous value and whose second
-	/// member is the current value. `initial` is supplied as the first member
-	/// when `self` sends its first value.
+	/// Forward events from `self` with history: values of the produced signal
+	/// are a tuples whose first member is the previous value and whose second member
+	/// is the current value.
+	///
+	/// If an initial value is given, the produced `Signal` would emit tuples as soon as
+	/// the first value is received. If `initial` is nil, the produced `Signal` would not
+	/// emit any tuple until it has received at least two values.
 	///
 	/// - parameters:
-	///   - initial: A value that will be combined with the first value sent by
-	///              `self`.
+	///   - initial: An optional initial value.
 	///
-	/// - returns: A producer that sends tuples that contain previous and
-	///            current sent values of `self`.
-	public func combinePrevious(_ initial: Value) -> SignalProducer<(Value, Value), Error> {
+	/// - returns: A producer that sends tuples that contain previous and current
+	///            sent values of `self`.
+	public func combinePrevious(_ initial: Value? = nil) -> SignalProducer<(Value, Value), Error> {
 		return lift { $0.combinePrevious(initial) }
 	}
 

Tests/ReactiveSwiftTests/SignalSpec.swift

@@ -2756,19 +2756,21 @@ class SignalSpec: QuickSpec {
 		}
 
 		describe("combinePrevious") {
+			var signal: Signal<Int, NoError>!
 			var observer: Signal<Int, NoError>.Observer!
 			let initialValue: Int = 0
 			var latestValues: (Int, Int)?
 
 			beforeEach {
 				latestValues = nil
 
-				let (signal, baseObserver) = Signal<Int, NoError>.pipe()
-				observer = baseObserver
-				signal.combinePrevious(initialValue).observeValues { latestValues = $0 }
+				let (baseSignal, baseObserver) = Signal<Int, NoError>.pipe()
+				(signal, observer) = (baseSignal, baseObserver)
 			}
 
-			it("should forward the latest value with previous value") {
+			it("should forward the latest value with previous value with the given initial value") {
+				signal.combinePrevious(initialValue).observeValues { latestValues = $0 }
+
 				expect(latestValues).to(beNil())
 
 				observer.send(value: 1)
@@ -2779,6 +2781,19 @@ class SignalSpec: QuickSpec {
 				expect(latestValues?.0) == 1
 				expect(latestValues?.1) == 2
 			}
+
+			it("should forward the latest value with previous value without any initial value") {
+				signal.combinePrevious().observeValues { latestValues = $0 }
+
+				expect(latestValues).to(beNil())
+
+				observer.send(value: 1)
+				expect(latestValues).to(beNil())
+
+				observer.send(value: 2)
+				expect(latestValues?.0) == 1
+				expect(latestValues?.1) == 2
+			}
 		}
 
 		describe("combineLatest") {