 	func buffer(capacity: Int? = nil) -> (Producer<T>, Disposable) {
 		let buffer = EventBuffer<T>(capacity: capacity)
 
+		// TODO: How does `self` get retained properly?
 		let observationDisposable = self.observe { value in
 			buffer.put(.Next(Box(value)))
 		}

	func combineLatestWith<U>(stream: Signal<U>) -> Signal<(T, U)> {
		return Signal<(T, U)>(initialValue: (self.current, stream.current)) { sink in
			// FIXME: This implementation is probably racey.
			self.observe { value in sink.put(value, stream.current) }
			stream.observe { value in sink.put(self.current, value) }
		}
	}


	init(initialValue: T, generator: SinkOf<T> -> ()) {
		_current = initialValue

		// Save the generator closure so that anything it captures (e.g.,
		// another Signal dependency) remains alive while this Signal object is
		// too.
		_generator = generator

		_generator(SinkOf { [weak self] value in
			if let strongSelf = self {
				dispatch_barrier_sync(strongSelf._queue) {
					strongSelf._current = value

					for sinkBox in strongSelf._observers {
						sinkBox.value.put(value)
					}
				}
			}
		})
