         return protected.withReadLock { $0.protectedValue }
     }
 
-    public func uponQueue(queue: dispatch_queue_t, block: T -> ()) {
+    public func upon(_ inQueue: dispatch_queue_t? = nil, function: T -> ()) {
+        let queue = inQueue ?? defaultQueue
         let maybeValue: T? = protected.withWriteLock{ data in
             if data.protectedValue == nil {
-                data.uponBlocks.append( (queue, block) )
+                data.uponBlocks.append( (queue, function) )
             }
             return data.protectedValue
         }
         if let value = maybeValue {
-            dispatch_async(queue) { block(value) }
+            dispatch_async(queue) { function(value) }
         }
     }
 }

extension Deferred {
    public func bindQueue<U>(queue: dispatch_queue_t, f: T -> Deferred<U>) -> Deferred<U> {
        let d = Deferred<U>()
        self.uponQueue(queue) {
            f($0).uponQueue(queue) {
                d.fill($0)
            }
        }


    for deferred in array {
        dispatch_group_enter(group)
        deferred.upon(DeferredDefaultQueue) { _ in
            dispatch_group_leave(group)
        }
    }
