 	///            `Signal` commences. Both the produced `Signal` and an interrupt handle
 	///            of the signal would be passed to the closure.
 	public func startWithSignal(_ setup: (_ signal: Signal<Value, Error>, _ interruptHandle: Disposable) -> Void) {
-		return core.startWithSignal(setup)
-	}
-}
-
+		let receipt = core.make()
+		setup(receipt.signal, receipt.interruptHandle)
+		guard !receipt.interruptHandle.isDisposed else { return }
+		receipt.observerDidSetup()
+	}
+}
+
+/// `SignalProducerCore` is the actual implementation of a `SignalProducer`.
+///
+/// While `SignalProducerCore` still requires all subclasses to be able to produce
+/// instances of `Signal`s, the abstraction enables room of optimization for common
+/// compositional and single-observer use cases.
 internal class SignalProducerCore<Value, Error: Swift.Error> {
-	/// Wraps a closure which, when invoked, produces a new instance of `Signal`, a
-	/// customized `observerDidSetup` post-creation side effect for the `Signal` and a
-	/// disposable to interrupt the produced `Signal`.
-	///
-	/// Unlike the safe `startWithSignal(_:)` API, `builder` shifts the responsibility of
-	/// invoking the post-creation side effect to the caller, while it takes from the
-	/// caller the responsibility of the `Signal` creation.
-	///
-	/// The design allows producer lifting to be as efficient as native `Signal`
-	/// operators, by eliminating the unnecessary relay `Signal` imposed by the old
-	/// `startWithSignal(_:)`, regardless of the fact that lifted operators can rely on
-	/// the upstreams for producer interruption.
-	///
-	/// `observerDidSetup` must be invoked before any other post-creation side effect.
-	struct Product {
+	/// `ProducedSignalReceipt` represents an instance of `Signal` created from a
+	/// `SignalProducer`. In addition to the `Signal` itself, it includes also the
+	/// starting side effect and an interrupt handle for this particular instance.
+	///
+	/// It is the responsibility of the `ProducedSignalReceipt` consumer to ensure the
+	/// starting side effect is invoked exactly once, and is invoked after observations
+	/// has properly setup.
+	struct ProducedSignalReceipt {
 		let signal: Signal<Value, Error>
 		let observerDidSetup: () -> Void
 		let interruptHandle: Disposable
 	}
 
-	func make() -> Product {
+	func make() -> ProducedSignalReceipt {
 		fatalError()
 	}
 
 	func start(_ observer: Signal<Value, Error>.Observer) -> Disposable {
-		var disposable: Disposable!
-
-		startWithSignal { signal, innerDisposable in
-			signal.observe(observer)
-			disposable = innerDisposable
-		}
-
-		return disposable
+		fatalError()
 	}
 
 	/// Perform an action upon every event from `self`. The action may generate zero or

		return SignalProducer<U, F>(SignalCore {
			// Transform the `Signal`, and pass through the `didCreate` side effect and
			// the interruptHandle.
			let instance = self.core.make()
			return .init(signal: transform(instance.signal),
			             observerDidSetup: instance.observerDidSetup,
			             interruptHandle: instance.interruptHandle)
			})
	}


		})
	}

	internal override func make() -> ProducedSignalReceipt {
		let product = source.make()
		let signal = Signal<Value, Error> { observer in
			return product.signal.observe(.init(observer, transform))
		}

		return ProducedSignalReceipt(signal: signal,
		                             observerDidSetup: product.observerDidSetup,
		                             interruptHandle: product.interruptHandle)
	}
}

/// `EventGeneratingCore` wraps a generator closure that would be invoked upon a produced
/// `Signal` when started. The generator closure is passed only the input observer and the
/// cancel disposable.
///
/// It is intended for constant `SignalProducers`s that synchronously emits all events
/// without escaping the `Observer`.
private final class EventGeneratingCore<Value, Error: Swift.Error>: SignalProducerCore<Value, Error> {
	private let generator: (Signal<Value, Error>.Observer, Disposable) -> Void

