     
     can only be used to a create a Future that should always succeed.
     */
-    public init(_ executor : Executor = .Immediate, block: () throws -> T) {
-        let block = executor.callbackBlockFor { () -> Void in
+    public init(_ executor : Executor = .Immediate , block: () throws -> T) {
+        let wrappedBlock = executor.callbackBlockFor { () -> Void in
             do {
                 let r = try block()
                 self.completeWith(.Success(r))

    
    the block can return a value of .CompleteUsing(Future<T>) if it wants this Future to complete with the results of another future.
    */
    public init<C:CompletionType where C.T == T>(_ executor : Executor = .Immediate, block: () throws -> C) {
        executor.execute { () -> Void in
            do {
                self.completeWith(try block())
            }
            catch {
                self.completeWith(.Fail(error))
                
            }
        }
    }


    /**
    creates a completed Future.
    */
//    public init(result:FutureResult<T>) {  // returns an completed Task
//        self.__result = result
//    }
    /**
        creates a completed Future with a completion == .Success(success)
    */
