 		_signal = { property.signal }
 	}
 
-	/// Initializes a property that first takes on `initial`, then each value
+	/// Initializes a composed property that first takes on `initialValue`, then each value
 	/// sent on a signal created by `producer`.
 	public init(initial: Value, then producer: SignalProducer<Value, NoError>) {
 		self.init(unsafeProducer: producer.prefix(value: initial),
 		          capturing: [])
 	}
 
-	/// Initializes a property that first takes on `initial`, then each value
+	/// Initializes a composed property that first takes on `initialValue`, then each value
 	/// sent on `signal`.
 	public init(initial: Value, then signal: Signal<Value, NoError>) {
 		self.init(unsafeProducer: SignalProducer(signal: signal).prefix(value: initial),
 		          capturing: [])
 	}
 
-	/// Initializes a property by applying the unary `SignalProducer` transform on
+	/// Initializes a composed property by applying the unary `SignalProducer` transform on
 	/// `property`. The resulting property captures `property`.
 	private init<P: PropertyProtocol>(_ property: P, transform: @noescape (SignalProducer<P.Value, NoError>) -> SignalProducer<Value, NoError>) {
 		self.init(unsafeProducer: transform(property.producer),
 		          capturing: Property.capture(property))
 	}
 
-	/// Initializes a property by applying the binary `SignalProducer` transform on
-	/// `firstProperty` and `secondProperty`. The resulting property captures
-	/// the two property sources.
+	/// Initializes a composed property by applying the binary `SignalProducer` transform on
+	/// `property` and `anotherProperty`. The resulting property captures `property`
+	/// and `anotherProperty`.
 	private init<P1: PropertyProtocol, P2: PropertyProtocol>(_ firstProperty: P1, _ secondProperty: P2, transform: @noescape (SignalProducer<P1.Value, NoError>) -> (SignalProducer<P2.Value, NoError>) -> SignalProducer<Value, NoError>) {
 		self.init(unsafeProducer: transform(firstProperty.producer)(secondProperty.producer),
 		          capturing: Property.capture(firstProperty) + Property.capture(secondProperty))
 	}
 
-	/// Initializes a property from a producer that promises to send at least one
+	/// Initializes a composed property from a producer that promises to send at least one
 	/// value synchronously in its start handler before sending any subsequent event.
 	/// If the producer fails its promise, a fatal error would be raised.
 	///

	}
}

/// A read-only, type-erased view of a property.
public struct Property<Value>: PropertyProtocol {
	private let sources: [Any]
	private let disposable: Disposable?

		_signal = { Signal<Value, NoError>.empty }
	}

	/// Initializes an existential property which wraps the given property.
	public init<P: PropertyProtocol where P.Value == Value>(_ property: P) {
		sources = Property.capture(property)
		disposable = nil
