 
     /// The given closures execute asynchronously when the future has a result.
     ///
+    /// By default, all of the callbacks and composing functions are executed on
+    /// the main queue (`DispatchQueue.main`). To change the queue use `observeOn`.
+    ///
     /// - parameter success: Gets called when the future has a value.
     /// - parameter failure: Gets called when the future has an error.
-    /// - parameter completed: Gets called when the future has any result.
+    /// - parameter completion: Gets called when the future has any result.
     public func on(success: ((Value) -> Void)? = nil, failure: ((Error) -> Void)? = nil, completion: (() -> Void)? = nil) {
         observe(success: { success?($0); completion?() },
                 failure: { failure?($0); completion?() })

    /// - parameter closure: The closure is called immediately on the current
    /// thread. You should start an asynchronous task and call either `succeed`
    /// or `fail` when it completes.
    public convenience init(_ closure: (_ succeed: @escaping (Value) -> Void, _ fail: @escaping (Error) -> Void) -> Void) {
        self.init(queue: .main, closure)
    }

    convenience init(queue: DispatchQueue, _ closure: (_ succeed: @escaping (Value) -> Void, _ fail: @escaping (Error) -> Void) -> Void) {
        self.init(queue: queue)
        closure({ self.succeed($0) }, { self.fail($0) }) // retain self
    }

    init(queue: DispatchQueue = .main) {

            return // already finished
        }
        self.state = newState

        assert(handlers != nil)
        switch newState {
        case .pending: fatalError("Invalid transition")
