 
 	/// A signal that will send the wrapped property's changes over time, then complete
 	/// when the wrapped property has deinitialized.
-	///
-	/// It is strongly discouraged to use `signal` on any transformed property.
 	public var signal: Signal<Value, NoError> {
 		return _signal()
 	}

	/// If the producer fails its promise, a fatal error would be raised.
	///
	/// The producer and the signal of the created property would complete only

	/// when the `propertyProducer` completes.
	private init(unsafeProducer: SignalProducer<Value, NoError>, capturing propertySources: [Any]) {
		// The relay would be indirectly retained by `AnyProperty` and also every produced
		/// signal from this relay through `scopedDisposable`.

		// A disposable that holds a reference to the relay, and the observer disposable
		// used for interrupting the started `propertyProducer`.
		let relayDisposable = CompositeDisposable()

		// A disposable that wraps the `relayDisposable`. All the consumers of the relay
		// would retain this disposable, so that when all parties go out of scope, the
		// started `propertyProducer` can be interrupted.
		let scopedDisposable = ScopedDisposable(relayDisposable)
		sources = propertySources + [scopedDisposable]

		let relay = MutableProperty<Value?>(nil)
		relayDisposable += { _ = relay }

		relayDisposable += unsafeProducer.start { [weak relay] event in
			switch event {
			case let .next(newValue):

/// The producer and the signal of transformed properties would complete
/// only when its source properties have deinitialized.
///
/// A composed property would retain its ultimate source, but not
/// any intermediate property during the composition.
extension PropertyProtocol {
	/// Lifts a unary SignalProducer operator to operate upon PropertyProtocol instead.
