 }
 
 extension Observable {
-	public func map <T> (_ transform: @escaping (Observed) -> T) -> Observable<T> {
+	///	Create a new `Observable` object that always keeps the same value as
+	///	this one, transformed through the given function. The updates are given
+	///	referring to the transformed value, and changes are determined in terms
+	///	of the result of the transformation.
+	///
+	///	- parameter transform: The transform between the value on this object
+	///		and the resulting one.
+	///	- parameter value: The `value` of this that gets transformed.
+	///	- returns: Another `Observable`, which notifies its subscribers of
+	///		updates on its transformed value.
+	public func map <T> (_ transform: @escaping (_ value: Observed) -> T) -> Observable<T> {
 		let mappedObservable = Observable<T>(transform(value))
 		subscribe(mappedObservable, onUpdate: { [weak mappedObservable] oldValue, newValue in
 			mappedObservable?.value = transform(newValue)

		addObserver(with: identifier, onUpdate: autoreleasingOnUpdate)
    }

	public func unsubscribe(_ observer: AnyObject) {
		let identifier = ObjectIdentifier(observer)
		removeObserver(with: identifier)

}

extension Observable where Observed: Equatable {
	/// Subscribe to changes on the wrapped value with the passed function, but
	///	only when it gets set to a different value. That's the only difference
	///	from a classic subscription.
	///	- seealso: `subscribe(_:onUpdate:)`
	///
	///	- parameter observer: The object that owns the subscription.
	///	- parameter onChange: The function that will get called on every update
	///		of the wrapped value to a different value.
	public func subscribe(_ observer: AnyObject, onChange: @escaping UpdateAction) {
		subscribe(observer, onUpdate: { oldValue, newValue in
			guard newValue != oldValue else { return }
