 		return d
 	}
 
-	internal override func make() -> Product {
+	internal override func make() -> ProducedSignalReceipt {
 		let (signal, observer) = Signal<Value, Error>.pipe()
 		let d = AnyDisposable(observer.sendInterrupted)
 
-		return Product(signal: signal,
-		               observerDidSetup: { self.generator(observer, d) },
-		               interruptHandle: d)
+		return ProducedSignalReceipt(signal: signal,
+		                             observerDidSetup: { self.generator(observer, d) },
+		                             interruptHandle: d)
 	}
 }
 

	///            `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)
	}
}

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 {
		let signal: Signal<Value, Error>
		let observerDidSetup: () -> Void
		let interruptHandle: Disposable
	}

	func make() -> Product {
		fatalError()
	}

	func start(_ observer: Signal<Value, Error>.Observer) -> Disposable {
		var disposable: Disposable!

		startWithSignal { signal, innerDisposable in
			signal.observe(observer)
			disposable = innerDisposable
		}

		return disposable
	}

	/// 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 receipt = self.core.make()
			return .init(signal: transform(receipt.signal),
			             observerDidSetup: receipt.observerDidSetup,
			             interruptHandle: receipt.interruptHandle)
			})
	}

