Merge pull request #642 from ReactiveCocoa/anders/binding-lhs-optional

Permit optional LHS in `<~` bindings.

Author: mdiep

CHANGELOG.md

@@ -1,9 +1,22 @@
 # master
 
+*Please add new entries at the top.*
 
-# 4.0.0-rc.21. Support Swift 4.2 (Xcode 10) (#644, kudos to @ikesyo) 
+1. `<~` bindings now works with optional left-hand-side operands. (#642, kudos to @andersio and @Ankit-Aggarwal)
 
-# 4.0.0-rc.1*Please add new entries at the top.*
+   ```swift
+   let nilTarget: BindingTarget<Int>? = nil
+
+   // This is now a valid binding. Previously required manual
+   // unwrapping in ReactiveSwift 3.x.
+   nilTarget <~ notifications.map { $0.count }
+   ```
+
+# 4.0.0-rc.2
+
+1. Support Swift 4.2 (Xcode 10) (#644, kudos to @ikesyo) 
+
+# 4.0.0-rc.1
 
 1. `Lifetime` may now be manually ended using `Lifetime.Token.dispose()`, in addition to the existing when-token-deinitializes semantic. (#641, kudos to @andersio) 
 1. For Swift 4.1 and above, `BindingSource` conformances are required to have `Error` parameterized as exactly `NoError`. As a result, `Signal` and `SignalProducer` are now conditionally `BindingSource`. (#590, kudos to @NachoSoto and @andersio)

Sources/UnidirectionalBinding.swift

@@ -149,3 +149,16 @@ public struct BindingTarget<Value>: BindingTargetProvider {
 		self.init(on: scheduler, lifetime: lifetime) { [weak object] in object?[keyPath: keyPath] = $0 }
 	}
 }
+
+extension Optional: BindingTargetProvider where Wrapped: BindingTargetProvider {
+	public typealias Value = Wrapped.Value
+
+	public var bindingTarget: BindingTarget<Wrapped.Value> {
+		switch self {
+		case let .some(provider):
+			return provider.bindingTarget
+		case .none:
+			return BindingTarget(lifetime: .empty, action: { _ in })
+		}
+	}
+}

Tests/ReactiveSwiftTests/UnidirectionalBindingSpec.swift

@@ -21,8 +21,8 @@ class UnidirectionalBindingSpec: QuickSpec {
 			}
 
 			describe("closure binding target") {
-				var target: BindingTarget<Int>!
-				var optionalTarget: BindingTarget<Int?>!
+				var target: BindingTarget<Int>?
+				var optionalTarget: BindingTarget<Int?>?
 				var value: Int?
 
 				beforeEach {
@@ -33,40 +33,57 @@ class UnidirectionalBindingSpec: QuickSpec {
 
 				describe("non-optional target") {
 					it("should pass through the lifetime") {
-						expect(target.lifetime).to(beIdenticalTo(lifetime))
+						expect(target!.lifetime).to(beIdenticalTo(lifetime))
 					}
 
 					it("should trigger the supplied setter") {
 						expect(value).to(beNil())
 
-						target.action(1)
+						target!.action(1)
 						expect(value) == 1
 					}
 
 					it("should accept bindings from properties") {
 						expect(value).to(beNil())
 
 						let property = MutableProperty(1)
-						target <~ property
+						target! <~ property
 						expect(value) == 1
 
 						property.value = 2
 						expect(value) == 2
 					}
 				}
 
-				describe("optional target") {
+				describe("target of optional value") {
 					it("should pass through the lifetime") {
-						expect(optionalTarget.lifetime).to(beIdenticalTo(lifetime))
+						expect(optionalTarget!.lifetime).to(beIdenticalTo(lifetime))
 					}
 
 					it("should trigger the supplied setter") {
 						expect(value).to(beNil())
 
-						optionalTarget.action(1)
+						optionalTarget!.action(1)
 						expect(value) == 1
 					}
 
+					it("should accept bindings from properties") {
+						expect(value).to(beNil())
+
+						let property = MutableProperty(1)
+						optionalTarget! <~ property
+						expect(value) == 1
+
+						property.value = 2
+						expect(value) == 2
+					}
+				}
+
+				describe("optional LHS binding with non-nil LHS at runtime") {
+					it("should pass through the lifetime") {
+						expect(target.bindingTarget.lifetime).to(beIdenticalTo(lifetime))
+					}
+
 					it("should accept bindings from properties") {
 						expect(value).to(beNil())
 
@@ -78,6 +95,13 @@ class UnidirectionalBindingSpec: QuickSpec {
 						expect(value) == 2
 					}
 				}
+
+				describe("optional LHS binding with nil LHS at runtime") {
+					it("should pass through the empty lifetime") {
+						let nilTarget: BindingTarget<Int>? = nil
+						expect(nilTarget.bindingTarget.lifetime).to(beIdenticalTo(Lifetime.empty))
+					}
+				}
 			}
 
 			describe("key path binding target") {