 		}
 	}
 
+	/// A signal of all future changes to this property's value.
 	public lazy var changes: HotSignal<T> = {
-		let (signal, sink) = HotSignal.pipe()
+		let (signal, sink) = HotSignal<T>.pipe()
 		let eventSink = SinkOf<Event<T>> { event in
 			switch (event) {
-			case .Next(value):
+			case let .Next(value):
 				sink.put(value.unbox)
+
+			default:
+				break
 			}
 		}
 
-		dispatch_sync(queue) {
-			self.sinks.append(eventSink)
+		dispatch_sync(self.queue) {
+			let token = self.sinks.insert(eventSink)
+			return ()
 		}
+
+		return signal
 	}()
 
 	init(_ value: T) {

		}
	}

	public func values() -> ColdSignal<T> {
		return ColdSignal { subscriber in
			var token: Bag.RemovalToken?

			dispatch_sync(queue) {
				token = self.sinks.insert(SinkOf(subscriber))
			}

			return ActionDisposable {
				self.sinks.removeValueForToken(token)
			}
		}
	}
}

//

import Foundation
import LlamaKit

/// A property of type T that allows the observation of its changes.
public final class ObservableProperty<T> {
	private let queue = dispatch_queue_create("com.github.ReactiveCocoa.ObservableProperty", DISPATCH_QUEUE_SERIAL)
	private var sinks = Bag<SinkOf<Event<T>>>()

	/// The current value of the property.
	///
	/// Setting this to a new value will notify all observers of `changes` and
	/// all subscribers to `values()`.
	public var value: T {
		didSet(value) {
			dispatch_sync(queue) {
