Merge branch 'master' into nesting-validating-prop

Author: andersio

CHANGELOG.md

@@ -3,6 +3,15 @@
 
 1. `ValidationResult` and `ValidatorOutput` have been renamed to `ValidatingProperty.Result` and `ValidatingProperty.Decision`, respectively. (#443)
 
+1. Mitigated a race condition related to ARC in the `Signal` internal. (#456, kudos to @andersio)
+
+1. Added new convenience initialisers to `Action` that make creating actions with state input properties easier. When creating an `Action` that is conditionally enabled based on an optional property, use the renamed `Action.init(unwrapping:execute:)` initialisers. (#455, kudos to @sharplet)
+
+# 2.0.0-alpha.3
+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. Fixed an impedance mismatch in the `Signal` internals that caused heap corruptions. (#449, kudos to @gparker42)
+
 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

Documentation/FrameworkOverview.md

@@ -211,7 +211,7 @@ Schedulers are also somewhat similar to `NSOperationQueue`, but schedulers
 do not allow tasks to be reordered or depend on one another.
 
 
-[Design Guidelines]: DesignGuidelines.md
+[Design Guidelines]: APIContracts.md
 [BasicOperators]: BasicOperators.md
 [README]: ../README.md
 [ReactiveCocoa]: https://github.com/ReactiveCocoa/

ReactiveSwift.podspec

@@ -1,7 +1,7 @@
 Pod::Spec.new do |s|
   s.name         = "ReactiveSwift"
   # Version goes here and will be used to access the git tag later on, once we have a first release.
-  s.version      = "2.0.0-alpha.2"
+  s.version      = "2.0.0-alpha.3"
   s.summary      = "Streams of values over time"
   s.description  = <<-DESC
                    ReactiveSwift is a Swift framework inspired by Functional Reactive Programming. It provides APIs for composing and transforming streams of values over time.

Sources/Action.swift

@@ -168,6 +168,20 @@ public final class Action<Input, Output, Error: Swift.Error> {
 		}
 	}
 
+	/// Initializes an `Action` that uses a property as its state.
+	///
+	/// When the `Action` is asked to start the execution, a unit of work — represented by
+	/// a `SignalProducer` — would be created by invoking `execute` with the latest value
+	/// of the state.
+	///
+	/// - parameters:
+	///   - state: A property to be the state of the `Action`.
+	///   - execute: A closure that produces a unit of work, as `SignalProducer`, to
+	///              be executed by the `Action`.
+	public convenience init<P: PropertyProtocol>(state: P, execute: @escaping (P.Value, Input) -> SignalProducer<Output, Error>) {
+		self.init(state: state, enabledIf: { _ in true }, execute: execute)
+	}
+
 	/// Initializes an `Action` that would be conditionally enabled.
 	///
 	/// When the `Action` is asked to start the execution with an input value, a unit of
@@ -184,6 +198,25 @@ public final class Action<Input, Output, Error: Swift.Error> {
 		}
 	}
 
+	/// Initializes an `Action` that uses a property of optional as its state.
+	///
+	/// When the `Action` is asked to start executing, a unit of work (represented by
+	/// a `SignalProducer`) is created by invoking `execute` with the latest value
+	/// of the state and the `input` that was passed to `apply()`.
+	///
+	/// If the property holds a `nil`, the `Action` would be disabled until it is not
+	/// `nil`.
+	///
+	/// - parameters:
+	///   - state: A property of optional to be the state of the `Action`.
+	///   - execute: A closure that produces a unit of work, as `SignalProducer`, to
+	///              be executed by the `Action`.
+	public convenience init<P: PropertyProtocol, T>(unwrapping state: P, execute: @escaping (T, Input) -> SignalProducer<Output, Error>) where P.Value == T? {
+		self.init(state: state, enabledIf: { $0 != nil }) { state, input in
+			execute(state!, input)
+		}
+	}
+
 	/// Initializes an `Action` that would always be enabled.
 	///
 	/// When the `Action` is asked to start the execution with an input value, a unit of
@@ -252,9 +285,9 @@ extension Action where Input == Void {
 	///   - state: A property of optional to be the state of the `Action`.
 	///   - execute: A closure that produces a unit of work, as `SignalProducer`, to
 	///              be executed by the `Action`.
-	public convenience init<P: PropertyProtocol, T>(state: P, execute: @escaping (T) -> SignalProducer<Output, Error>) where P.Value == T? {
-		self.init(state: state, enabledIf: { $0 != nil }) { state, _ in
-			execute(state!)
+	public convenience init<P: PropertyProtocol, T>(unwrapping state: P, execute: @escaping (T) -> SignalProducer<Output, Error>) where P.Value == T? {
+		self.init(unwrapping: state) { state, _ in
+			execute(state)
 		}
 	}
 
@@ -269,7 +302,9 @@ extension Action where Input == Void {
 	///   - execute: A closure that produces a unit of work, as `SignalProducer`, to
 	///              be executed by the `Action`.
 	public convenience init<P: PropertyProtocol, T>(state: P, execute: @escaping (T) -> SignalProducer<Output, Error>) where P.Value == T {
-		self.init(state: state.map(Optional.some), execute: execute)
+		self.init(state: state) { state, _ in
+			execute(state)
+		}
 	}
 }
 

Sources/Deprecations+Removals.swift

@@ -141,7 +141,10 @@ extension Action {
 }
 
 extension Action where Input == Void {
-	@available(*, unavailable, renamed:"init(state:execute:)")
+	@available(*, unavailable, renamed:"init(unwrapping:execute:)")
+	public convenience init<P: PropertyProtocol, T>(state: P, _ execute: @escaping (T) -> SignalProducer<Output, Error>) where P.Value == T? { fatalError() }
+
+	@available(*, unavailable, renamed:"init(unwrapping:execute:)")
 	public convenience init<P: PropertyProtocol, T>(input: P, _ execute: @escaping (T) -> SignalProducer<Output, Error>) where P.Value == T? { fatalError() }
 
 	@available(*, unavailable, renamed:"init(state:execute:)")

Sources/Flatten.swift

@@ -9,20 +9,32 @@
 import enum Result.NoError
 
 /// Describes how multiple producers should be joined together.
-public enum FlattenStrategy: Equatable {
+public struct FlattenStrategy {
+	fileprivate enum Kind {
+		case concurrent(limit: UInt)
+		case latest
+		case race
+	}
+
+	fileprivate let kind: Kind
+
+	private init(kind: Kind) {
+		self.kind = kind
+	}
+
 	/// The producers should be merged, so that any value received on any of the
 	/// input producers will be forwarded immediately to the output producer.
 	///
 	/// The resulting producer will complete only when all inputs have
 	/// completed.
-	public static let merge = FlattenStrategy.concurrent(limit: .max)
+	public static let merge = FlattenStrategy(kind: .concurrent(limit: .max))
 
 	/// The producers should be concatenated, so that their values are sent in
 	/// the order of the producers themselves.
 	///
 	/// The resulting producer will complete only when all inputs have
 	/// completed.
-	public static let concat = FlattenStrategy.concurrent(limit: 1)
+	public static let concat = FlattenStrategy(kind: .concurrent(limit: 1))
 
 	/// The producers should be merged, but only up to the given limit at any
 	/// point of time, so that any value received on any of the input producers
@@ -35,15 +47,17 @@ public enum FlattenStrategy: Equatable {
 	/// completed.
 	///
 	/// - precondition: `limit > 0`.
-	case concurrent(limit: UInt)
+	public static func concurrent(limit: UInt) -> FlattenStrategy {
+		return FlattenStrategy(kind: .concurrent(limit: limit))
+	}
 
 	/// Only the events from the latest input producer should be considered for
 	/// the output. Any producers received before that point will be disposed
 	/// of.
 	///
 	/// The resulting producer will complete only when the producer-of-producers
 	/// and the latest producer has completed.
-	case latest
+	public static let latest = FlattenStrategy(kind: .latest)
 
 	/// Only the events from the "first input producer to send an event" (winning producer)
 	/// should be considered for the output.
@@ -53,20 +67,7 @@ public enum FlattenStrategy: Equatable {
 	/// The resulting producer will complete when:
 	/// 1. The producer-of-producers and the first "alive" producer has completed.
 	/// 2. The producer-of-producers has completed without inner producer being "alive".
-	case race
-
-	public static func ==(left: FlattenStrategy, right: FlattenStrategy) -> Bool {
-		switch (left, right) {
-		case (.latest, .latest):
-			return true
-
-		case (.concurrent(let leftLimit), .concurrent(let rightLimit)):
-			return leftLimit == rightLimit
-
-		default:
-			return false
-		}
-	}
+	public static let race = FlattenStrategy(kind: .race)
 }
 
 extension Signal where Value: SignalProducerConvertible, Error == Value.Error {
@@ -82,7 +83,7 @@ extension Signal where Value: SignalProducerConvertible, Error == Value.Error {
 	/// - parameters:
 	///	  - strategy: Strategy used when flattening signals.
 	public func flatten(_ strategy: FlattenStrategy) -> Signal<Value.Value, Error> {
-		switch strategy {
+		switch strategy.kind {
 		case .concurrent(let limit):
 			return self.concurrent(limit: limit)
 
@@ -124,7 +125,7 @@ extension Signal where Value: SignalProducerConvertible, Error == NoError, Value
 	/// - parameters:
 	///   - strategy: Strategy used when flattening signals.
 	public func flatten(_ strategy: FlattenStrategy) -> Signal<Value.Value, Value.Error> {
-		switch strategy {
+		switch strategy.kind {
 		case .concurrent(let limit):
 			return self.concurrent(limit: limit)
 
@@ -167,7 +168,7 @@ extension SignalProducer where Value: SignalProducerConvertible, Error == Value.
 	/// - parameters:
 	///   - strategy: Strategy used when flattening signals.
 	public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Error> {
-		switch strategy {
+		switch strategy.kind {
 		case .concurrent(let limit):
 			return self.concurrent(limit: limit)
 
@@ -209,7 +210,7 @@ extension SignalProducer where Value: SignalProducerConvertible, Error == NoErro
 	/// - parameters:
 	///   - strategy: Strategy used when flattening signals.
 	public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Value.Error> {
-		switch strategy {
+		switch strategy.kind {
 		case .concurrent(let limit):
 			return self.concurrent(limit: limit)