     }
 
     /// Creates a future with a given value.
-    public init(value: Value) {
+    public convenience init(value: Value) {
+        self.init(state: .success(value))
+    }
+
+    /// Creates a future with a given error.
+    public convenience init(error: Error) {
+        self.init(state: .failure(error))
+    }
+
+    private init(state: State) {
         self.queue = .main
-        self.state = .success(value)
-        // no need to create handlers
-    }
-
-    /// Creates a future with a given error.
-    public init(error: Error) {
-        self.queue = .main
-        self.state = .failure(error)
-        // no need to create handlers
+        self.state = state
+        // No need to create handlers
     }
 
     // MARK: State Transitions

/// functions like `map`, `flatMap`, `zip`, `reduce` and more to compose futures.
///
/// By default, all of the callbacks and composing functions are executed on the
/// main queue (`DispatchQueue.main`). To change the queue use `observeOn` method
/// which creates a new future observed on the given queue.
public final class Future<Value, Error> {
    private var state: State = .pending
    private var handlers: Handlers? // nil when finished


    /// 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 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?() })
