     _ 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)
+      return ($0 as! AbstractPromiseState<Success>).complete(completion: completion)
+    }
+    let didComplete = (oldHead !== newHead)
     guard didComplete else { return false }
 
-    var nextItem = oldHead
-    while let currentItem = nextItem as? AbstractPromiseState<Success> {
-      nextItem = currentItem.handleCompletion(completion, from: originalExecutor)
+    var nextItem = oldHead as! AbstractPromiseState<Success>?
+    while let currentItem = nextItem {
+      nextItem = currentItem.didComplete(completion, from: originalExecutor)
     }
     _releasePool.drain()
 

    executor: Executor,
    _ block: @escaping (_ completion: Fallible<Success>, _ originalExecutor: Executor) -> Void
    ) -> AnyObject? {
    let handler = PromiseHandler(executor: executor, block: block, owner: self)

    let (oldHead, _) = _container.updateHead {
      switch $0 {
      case let completedState as CompletedPromiseState<Success>:
        handler.handle(completedState.value, from: nil)
        return $0
      case let incompleteState as SubscribedPromiseState<Success>:
        return SubscribedPromiseState(handler: handler, next: incompleteState)
      case is InitialPromiseState<Success>:
        return SubscribedPromiseState(handler: handler, next: nil)
      case .none:
        return SubscribedPromiseState(handler: handler, next: nil)
      default:
        fatalError()
      }
    }

    (oldHead as? AbstractPromiseState<Success>)?.handleSubscription()

    return handler
  }


/// **internal use only**
fileprivate  class SubscribedPromiseState<Success>: AbstractPromiseState<Success> {
  weak private var handler: PromiseHandler<Success>?
  let next: SubscribedPromiseState<Success>?

  init(handler: PromiseHandler<Success>, next: SubscribedPromiseState<Success>?) {
    self.handler = handler
    self.next = next
  }

  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>? {
    if let handler = self.handler {
      handler.handle(value, from: originalExecutor)
      handler.releaseOwner()
    }
    return next
  }
}

/// **internal use only**
fileprivate  class CompletedPromiseState<Success>: AbstractPromiseState<Success> {
  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
  }
}

