Merge pull request #120 from ReactiveCocoa/producer-init

Drop the label of `SignalProducer` initializers that take a sequence.

Author: mdiep

ReactiveSwift.playground/Pages/SignalProducer.xcplaygroundpage/Contents.swift

@@ -262,7 +262,7 @@ scopedExample("`mapError`") {
 Preserves only the values of the producer that pass the given predicate.
 */
 scopedExample("`filter`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.filter { $0 > 3 }
 		.startWithValues { value in
 			print(value)
@@ -275,7 +275,7 @@ Returns a producer that will yield the first `count` values from the
 input producer.
 */
 scopedExample("`take(first:)`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.take(first: 2)
 		.startWithValues { value in
 			print(value)
@@ -288,7 +288,7 @@ Forwards all events onto the given scheduler, instead of whichever
 scheduler they originally arrived upon.
 */
 scopedExample("`observe(on:)`") {
-	let baseProducer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	let baseProducer = SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 	let completion = { print("is main thread? \(Thread.current.isMainThread)") }
 
 	baseProducer
@@ -391,8 +391,8 @@ least one value each. If either producer is interrupted, the returned producer
 will also be interrupted.
 */
 scopedExample("`combineLatest(with:)`") {
-	let producer1 = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
-	let producer2 = SignalProducer<Int, NoError>(values: [ 1, 2 ])
+	let producer1 = SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
+	let producer2 = SignalProducer<Int, NoError>([ 1, 2 ])
 
 	producer1
 		.combineLatest(with: producer2)
@@ -407,7 +407,7 @@ Returns a producer that will skip the first `count` values, then forward
 everything afterward.
 */
 scopedExample("`skip(first:)`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.skip(first: 2)
 		.startWithValues { value in
 			print(value)
@@ -427,7 +427,7 @@ the Event itself and then complete. When an Interrupted event is received,
 the resulting producer will send the Event itself and then interrupt.
 */
 scopedExample("`materialize`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.materialize()
 		.startWithValues { value in
 			print(value)
@@ -447,8 +447,8 @@ multiple times) by `sampler`, then complete once both input producers have
 completed, or interrupt if either input producer is interrupted.
 */
 scopedExample("`sample(on:)`") {
-	let baseProducer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
-	let sampledOnProducer = SignalProducer<Int, NoError>(values: [ 1, 2 ])
+	let baseProducer = SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
+	let sampledOnProducer = SignalProducer<Int, NoError>([ 1, 2 ])
 		.map { _ in () }
 
 	baseProducer
@@ -466,7 +466,7 @@ is the current value. `initial` is supplied as the first member when `self`
 sends its first value.
 */
 scopedExample("`combinePrevious`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.combinePrevious(42)
 		.startWithValues { value in
 			print("\(value)")
@@ -482,7 +482,7 @@ producer returned from `scan`. That result is then passed to `combine` as the
 first argument when the next value is emitted, and so on.
 */
 scopedExample("`scan`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.scan(0, +)
 		.startWithValues { value in
 			print(value)
@@ -494,7 +494,7 @@ scopedExample("`scan`") {
 Like `scan`, but sends only the final value and then immediately completes.
 */
 scopedExample("`reduce`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.reduce(0, +)
 		.startWithValues { value in
 			print(value)
@@ -507,7 +507,7 @@ Forwards only those values from `self` which do not pass `isRepeat` with
 respect to the previous value. The first value is always forwarded.
 */
 scopedExample("`skipRepeats`") {
-	SignalProducer<Int, NoError>(values: [ 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 2, 2, 2, 4 ])
+	SignalProducer<Int, NoError>([ 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 2, 2, 2, 4 ])
 		.skipRepeats(==)
 		.startWithValues { value in
 			print(value)
@@ -521,7 +521,7 @@ at which point the returned signal behaves exactly like `self`.
 */
 scopedExample("`skip(while:)`") {
 	// Note that trailing closure is used for `skip(while:)`.
-	SignalProducer<Int, NoError>(values: [ 3, 3, 3, 3, 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 3, 3, 3, 3, 1, 2, 3, 4 ])
 		.skip { $0 > 2 }
 		.startWithValues { value in
 			print(value)
@@ -566,7 +566,7 @@ Waits until `self` completes and then forwards the final `count` values
 on the returned producer.
 */
 scopedExample("`take(last:)`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.take(last: 2)
 		.startWithValues { value in
 			print(value)
@@ -579,7 +579,7 @@ Unwraps non-`nil` values and forwards them on the returned signal, `nil`
 values are dropped.
 */
 scopedExample("`skipNil`") {
-	SignalProducer<Int?, NoError>(values: [ nil, 1, 2, nil, 3, 4, nil ])
+	SignalProducer<Int?, NoError>([ nil, 1, 2, nil, 3, 4, nil ])
 		.skipNil()
 		.startWithValues { value in
 			print(value)
@@ -593,8 +593,8 @@ Zips elements of two producers into pairs. The elements of any Nth pair
 are the Nth elements of the two input producers.
 */
 scopedExample("`zip(with:)`") {
-	let baseProducer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
-	let zippedProducer = SignalProducer<Int, NoError>(values: [ 42, 43 ])
+	let baseProducer = SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
+	let zippedProducer = SignalProducer<Int, NoError>([ 42, 43 ])
 
 	baseProducer
 		.zip(with: zippedProducer)
@@ -651,7 +651,7 @@ which case `replacement` will not be started, and none of its events will be
 be forwarded. All values sent from `producer` are ignored.
 */
 scopedExample("`then`") {
-	let baseProducer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	let baseProducer = SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 	let thenProducer = SignalProducer<Int, NoError>(value: 42)
 
 	baseProducer
@@ -686,7 +686,7 @@ a layer of caching in front of another `SignalProducer`.
 This operator has the same semantics as `SignalProducer.buffer`.
 */
 scopedExample("`replayLazily(upTo:)`") {
-	let baseProducer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4, 42 ])
+	let baseProducer = SignalProducer<Int, NoError>([ 1, 2, 3, 4, 42 ])
 		.replayLazily(upTo: 2)
 
 	baseProducer.startWithValues { value in
@@ -712,7 +712,7 @@ If `self` or any of the created producers fail, the returned producer
 will forward that failure immediately.
 */
 scopedExample("`flatMap(.latest)`") {
-	SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
+	SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
 		.flatMap(.latest) { SignalProducer(value: $0 + 3) }
 		.startWithValues { value in
 			print(value)
@@ -743,8 +743,8 @@ sampled (possibly multiple times) by `sampler`, then complete once both
 input producers have completed, or interrupt if either input producer is interrupted.
 */
 scopedExample("`sample(with:)`") {
-	let producer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4 ])
-	let sampler = SignalProducer<String, NoError>(values: [ "a", "b" ])
+	let producer = SignalProducer<Int, NoError>([ 1, 2, 3, 4 ])
+	let sampler = SignalProducer<String, NoError>([ "a", "b" ])
 
 	let result = producer.sample(with: sampler)
 
@@ -759,7 +759,7 @@ Logs all events that the receiver sends.
 By default, it will print to the standard output.
 */
 scopedExample("`log events`") {
-	let baseProducer = SignalProducer<Int, NoError>(values: [ 1, 2, 3, 4, 42 ])
+	let baseProducer = SignalProducer<Int, NoError>([ 1, 2, 3, 4, 42 ])
 
  	baseProducer
  		.logEvents(identifier: "Playground is fun!")

Sources/Deprecations+Removals.swift

@@ -297,6 +297,12 @@ extension SignalProducerProtocol where Error == NoError {
 extension SignalProducer {
 	@available(*, unavailable, message:"Use properties instead. `buffer(_:)` is removed in RAC 5.0.")
 	public static func buffer(_ capacity: Int) -> (SignalProducer, Signal<Value, Error>.Observer) { fatalError() }
+
+	@available(*, unavailable, renamed:"init(_:)")
+	public init<S: SignalProtocol>(signal: S) where S.Value == Value, S.Error == Error { fatalError() }
+
+	@available(*, unavailable, renamed:"init(_:)")
+	public init<S: Sequence>(values: S) where S.Iterator.Element == Value { fatalError() }
 }
 
 extension PropertyProtocol {

Sources/Flatten.swift

@@ -249,7 +249,7 @@ extension SignalProtocol where Value: Sequence, Error == NoError {
 	/// Flattens the `sequence` value sent by `signal` according to
 	/// the semantics of the given strategy.
 	public func flatten(_ strategy: FlattenStrategy) -> Signal<Value.Iterator.Element, Error> {
-		return self.flatMap(strategy) { .init(values: $0) }
+		return self.flatMap(strategy) { .init($0) }
 	}
 }
 
@@ -316,7 +316,7 @@ extension SignalProducerProtocol where Value: Sequence, Error == NoError {
 	/// Flattens the `sequence` value sent by `producer` according to
 	/// the semantics of the given strategy.
 	public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Iterator.Element, Error> {
-		return self.flatMap(strategy) { .init(values: $0) }
+		return self.flatMap(strategy) { .init($0) }
 	}
 }
 
@@ -440,7 +440,7 @@ extension SignalProducerProtocol where Value: SignalProducerProtocol, Error == V
 extension SignalProducerProtocol {
 	/// `concat`s `next` onto `self`.
 	public func concat(_ next: SignalProducer<Value, Error>) -> SignalProducer<Value, Error> {
-		return SignalProducer<SignalProducer<Value, Error>, Error>(values: [ self.producer, next ]).flatten(.concat)
+		return SignalProducer<SignalProducer<Value, Error>, Error>([ self.producer, next ]).flatten(.concat)
 	}
 
 	/// `concat`s `value` onto `self`.
@@ -578,7 +578,7 @@ extension SignalProtocol {
 	public static func merge<Seq: Sequence, S: SignalProtocol>(_ signals: Seq) -> Signal<Value, Error>
 		where S.Value == Value, S.Error == Error, Seq.Iterator.Element == S
 	{
-		return SignalProducer<S, Error>(values: signals)
+		return SignalProducer<S, Error>(signals)
 			.flatten(.merge)
 			.startAndRetrieveSignal()
 	}
@@ -599,7 +599,7 @@ extension SignalProducerProtocol {
 	public static func merge<Seq: Sequence, S: SignalProducerProtocol>(_ producers: Seq) -> SignalProducer<Value, Error>
 		where S.Value == Value, S.Error == Error, Seq.Iterator.Element == S
 	{
-		return SignalProducer(values: producers).flatten(.merge)
+		return SignalProducer(producers).flatten(.merge)
 	}
 
 	/// Merges the given producers into a single `SignalProducer` that will emit

Sources/Property.swift

@@ -456,20 +456,20 @@ public final class Property<Value>: PropertyProtocol {
 	///
 	/// - parameters:
 	///   - initial: Starting value for the property.
-	///   - producer: A producer that will start immediately and send values to
-	///               the property.
-	public convenience init(initial: Value, then producer: SignalProducer<Value, NoError>) {
-		self.init(unsafeProducer: producer.prefix(value: initial))
+	///   - values: A producer that will start immediately and send values to
+	///             the property.
+	public convenience init(initial: Value, then values: SignalProducer<Value, NoError>) {
+		self.init(unsafeProducer: values.prefix(value: initial))
 	}
 
 	/// Initialize a composed property that first takes on `initial`, then each
 	/// value sent on `signal`.
 	///
 	/// - parameters:
 	///   - initialValue: Starting value for the property.
-	///   - signal: A signal that will send values to the property.
-	public convenience init(initial: Value, then signal: Signal<Value, NoError>) {
-		self.init(unsafeProducer: SignalProducer(signal: signal).prefix(value: initial))
+	///   - values: A signal that will send values to the property.
+	public convenience init(initial: Value, then values: Signal<Value, NoError>) {
+		self.init(unsafeProducer: SignalProducer(values).prefix(value: initial))
 	}
 
 	/// Initialize a composed property by applying the unary `SignalProducer`

Sources/SignalProducer.swift

@@ -29,7 +29,7 @@ public struct SignalProducer<Value, Error: Swift.Error> {
 	///
 	/// - parameters:
 	///   - signal: A signal to observe after starting the producer.
-	public init<S: SignalProtocol>(signal: S) where S.Value == Value, S.Error == Error {
+	public init<S: SignalProtocol>(_ signal: S) where S.Value == Value, S.Error == Error {
 		self.init { observer, disposable in
 			disposable += signal.observe(observer)
 		}
@@ -100,7 +100,7 @@ public struct SignalProducer<Value, Error: Swift.Error> {
 	/// - parameters:
 	///   - values: A sequence of values that a `Signal` will send as separate
 	///             `value` events and then complete.
-	public init<S: Sequence>(values: S) where S.Iterator.Element == Value {
+	public init<S: Sequence>(_ values: S) where S.Iterator.Element == Value {
 		self.init { observer, disposable in
 			for value in values {
 				observer.send(value: value)
@@ -122,7 +122,7 @@ public struct SignalProducer<Value, Error: Swift.Error> {
 	///   - second: Second value for the `Signal` to send.
 	///   - tail: Rest of the values to be sent by the `Signal`.
 	public init(values first: Value, _ second: Value, _ tail: Value...) {
-		self.init(values: [ first, second ] + tail)
+		self.init([ first, second ] + tail)
 	}
 
 	/// A producer for a Signal that will immediately complete without sending
@@ -448,7 +448,7 @@ extension SignalProducerProtocol {
 	///            `SignalProducer`.
 	public func lift<U, F, V, G>(_ transform: @escaping (Signal<Value, Error>) -> (Signal<U, F>) -> Signal<V, G>) -> (Signal<U, F>) -> SignalProducer<V, G> {
 		return { otherSignal in
-			return self.liftRight(transform)(SignalProducer(signal: otherSignal))
+			return self.liftRight(transform)(SignalProducer(otherSignal))
 		}
 	}
 

Tests/ReactiveSwiftTests/PropertySpec.swift

@@ -578,7 +578,7 @@ class PropertySpec: QuickSpec {
 
 						let (signal, observer) = Signal<Int, NoError>.pipe()
 						var property: Property<Int>? = Property(initial: 1,
-																											 then: SignalProducer(signal: signal))
+						                                        then: SignalProducer(signal))
 						let propertySignal = property!.signal
 
 						propertySignal.observeCompleted { signalCompleted = true }
@@ -1539,7 +1539,7 @@ class PropertySpec: QuickSpec {
 			describe("from a SignalProducer") {
 				it("should start a signal and update the property with its values") {
 					let signalValues = [initialPropertyValue, subsequentPropertyValue]
-					let signalProducer = SignalProducer<String, NoError>(values: signalValues)
+					let signalProducer = SignalProducer<String, NoError>(signalValues)
 
 					let mutableProperty = MutableProperty(initialPropertyValue)
 
@@ -1562,7 +1562,7 @@ class PropertySpec: QuickSpec {
 
 				it("should tear down the binding when the property deallocates") {
 					let (signal, _) = Signal<String, NoError>.pipe()
-					let signalProducer = SignalProducer(signal: signal)
+					let signalProducer = SignalProducer(signal)
 
 					var mutableProperty: MutableProperty<String>? = MutableProperty(initialPropertyValue)
 

Tests/ReactiveSwiftTests/SignalProducerLiftingSpec.swift

@@ -999,7 +999,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 			}
 
 			it("should emit an initial value if the sampler is a synchronous SignalProducer") {
-				let producer = SignalProducer<Int, NoError>(values: [1])
+				let producer = SignalProducer<Int, NoError>([1])
 				let sampler = SignalProducer<String, NoError>(value: "a")
 
 				let result = producer.sample(with: sampler)
@@ -1064,7 +1064,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 			}
 
 			it("should emit an initial value if the sampler is a synchronous SignalProducer") {
-				let producer = SignalProducer<Int, NoError>(values: [1])
+				let producer = SignalProducer<Int, NoError>([1])
 				let sampler = SignalProducer<(), NoError>(value: ())
 
 				let result = producer.sample(on: sampler)