 
     func cascade(completion: @escaping (Result) -> Void) {
         if let scheduler = self.scheduler {
-            cascadeImmediately(completion: { result in
+            _cascade { result in
                 scheduler { completion(result) }
-            })
+            }
         } else {
-            cascadeImmediately(completion: completion)
-        }
-    }
-
-    private func cascadeImmediately(completion: @escaping (Result) -> Void) {
+            _cascade(completion: completion)
+        }
+    }
+
+    private func _cascade(completion: @escaping (Result) -> Void) {
         switch resolver {
         case let .promise(promise):
             promise.observe(completion: completion)

// MARK: - Disambiguate Init

extension Future where Error == Never {
    public init(value: Value) {
        self.init(result: .success(value))
    }

}

extension Future where Error == Never {
    /// A special variant that doesn't require a `failure` closure -
    /// `Future<Value, Never>` can't produce an error.
    func cascade(success: @escaping (Value) -> Void) {
        cascade(success: success, failure: { _ in fatalError("Future<Value, Never> can't produce an error") })
    }
