 
 /// **internal use only**
 fileprivate  class SubscribedPromiseState<Success>: AbstractPromiseState<Success> {
-  typealias Value = Fallible<Success>
-  typealias Handler = PromiseHandler<Success>
-
-  weak private var handler: Handler?
+  weak private var handler: PromiseHandler<Success>?
   let next: SubscribedPromiseState<Success>?
 
-  init(handler: Handler, next: SubscribedPromiseState<Success>?) {
+  init(handler: PromiseHandler<Success>, next: SubscribedPromiseState<Success>?) {
     self.handler = handler
     self.next = next
   }
 
-  override func handleCompletion(
+  override func subscribe(
+    owner: Future<Success>,
+    handler: inout PromiseHandler<Success>?,
+    executor: Executor,
+    _ block: @escaping (_ completion: Fallible<Success>, _ originalExecutor: Executor) -> Void
+    ) -> AbstractPromiseState<Success> {
+    let localHandler = PromiseHandler(executor: executor, block: block, owner: owner)
+    handler = localHandler
+    return SubscribedPromiseState(handler: localHandler, next: self)
+  }
+
+  override func didComplete(
     _ value: Fallible<Success>,
     from originalExecutor: Executor?
     ) -> AbstractPromiseState<Success>? {
-    let handler = self.handler
-    handler?.handle(value, from: originalExecutor)
-    handler?.releaseOwner()
+    if let handler = self.handler {
+      handler.handle(value, from: originalExecutor)
+      handler.releaseOwner()
+    }
     return next
   }
 }
 
 /// **internal use only**
 fileprivate  class CompletedPromiseState<Success>: AbstractPromiseState<Success> {
-  let value: Fallible<Success>
-
-  init(value: Fallible<Success>) {
-    self.value = value
+  override var completion: Fallible<Success>? { return _completion }
+  let _completion: Fallible<Success>
+
+  init(completion: Fallible<Success>) {
+    _completion = completion
+  }
+
+  override func subscribe(
+    owner: Future<Success>,
+    handler: inout PromiseHandler<Success>?,
+    executor: Executor,
+    _ block: @escaping (_ completion: Fallible<Success>, _ originalExecutor: Executor) -> Void
+    ) -> AbstractPromiseState<Success> {
+    return self
+  }
+
+  override func didSubscribe(
+    executor: Executor,
+    _ block: @escaping (_ completion: Fallible<Success>, _ originalExecutor: Executor) -> Void) {
+    let localCompletion = _completion
+    executor.execute(from: nil) { (originalExecutor) in
+      block(localCompletion, originalExecutor)
+    }
+  }
+
+  override func complete(completion: Fallible<Success>) -> AbstractPromiseState<Success> {
+    return self
   }
 }
 

    _ completion: Fallible<Success>,
    from originalExecutor: Executor? = nil
    ) -> Bool {
    let completedItem = CompletedPromiseState(value: completion)
    let (oldHead, newHead) = _container.updateHead {
      switch $0 {
      case is InitialPromiseState<Success>:
        return completedItem
      case is SubscribedPromiseState<Success>:
        return completedItem
      case let oldCompletedItem as CompletedPromiseState<Success>:
        return oldCompletedItem
      case .none:
        return completedItem
      default:
        fatalError()
      }
    }
    let didComplete = (completedItem === newHead)
    guard didComplete else { return false }

    var nextItem = oldHead
    while let currentItem = nextItem as? AbstractPromiseState<Success> {
      nextItem = currentItem.handleCompletion(completion, from: originalExecutor)
    }
    _releasePool.drain()


    self.notifyBlock = notifyBlock
  }

  override func subscribe(
    owner: Future<Success>,
    handler: inout PromiseHandler<Success>?,
    executor: Executor,
    _ block: @escaping (_ completion: Fallible<Success>, _ originalExecutor: Executor) -> Void
    ) -> AbstractPromiseState<Success> {
    let localHandler = PromiseHandler(executor: executor, block: block, owner: owner)
    handler = localHandler
    return SubscribedPromiseState(handler: localHandler, next: nil)
  }

  override func didSubscribe(
    executor: Executor,
    _ block: @escaping (_ completion: Fallible<Success>,
    _ originalExecutor: Executor) -> Void) {
    notifyBlock(false)
  }

  override func didComplete(
    _ value: Fallible<Success>,
    from originalExecutor: Executor?
    ) -> AbstractPromiseState<Success>? {
