 }
 
 extension Deferred {
+    /**
+    Composes the recieving value with another.
+
+    :param: other Any other deferred value.
+
+    :returns: A value that becomes determined after both the reciever and the
+    given values become determined.
+    */
     public func both<OtherValue>(other: Deferred<OtherValue>) -> Deferred<(Value, OtherValue)> {
         return flatMap { t in other.map { u in (t, u) } }
     }
 }
 
+/**
+Compose a number of deferred values into a single deferred array.
+
+:param: deferreds Any collection whose elements are themselves deferred values.
+:return: A deferred array that is determined once all the given values are
+determined, in the same order.
+**/
 public func all<Value, Collection: CollectionType where Collection.Generator.Element == Deferred<Value>>(deferreds: Collection) -> Deferred<[Value]> {
     let array = Array(deferreds)
     if array.isEmpty {

        return d
    }

    public func map<NewValue>(upon queue: dispatch_queue_t = DeferredDefaultQueue, transform: Value -> NewValue) -> Deferred<NewValue> {
        let d = Deferred<NewValue>()
        upon(queue) {

            dispatch_async(queue) { block(filledValue) }
        }
    }
    
    /**
    Checks for and returns a determined value.
    
    :returns: The determined value, if already filled, or `nil`.
    */
    public func peek() -> Value? {
        return protected.withReadLock { $0.protected }
    }
    
    /**
    Call some function once the value is determined.
    
    If the value is already determined, the function will be submitted to the
    queue immediately. An `upon` call is alreadys executed asnychronously.
    
    :param: queue A dispatch queue for executing the given function on.
    :param: function A function that uses the determined value.
    */
    public func upon(_ queue: dispatch_queue_t = DeferredDefaultQueue, function: Value -> ()) {
        let maybeValue: Value? = protected.withWriteLock{ data in
            if data.protected == nil {
