             
             synchronizeWrite(self) { parent in
                 switch parent.state {
-                case .Pending:
-                    parent.onFulfilled.append(fulfiller)
-                    parent.onRejected.append(rejecter)
-                default:
-                    if let result = parent.result {
-                        switch result {
-                        case .Success(let value):
-                            fulfiller(value.unwrap)
-                        case .Failure(let reason):
-                            rejecter(reason)
-                        default:
-                            fatalError("Promise must have a success or failure result when not pending")
-                        }
-                    } else {
-                        fatalError("Promise is required to have a result when not pending")
-                    }
+                case .Pending(let info):
+                    info.onFulfilled.append(fulfiller)
+                    info.onRejected.append(rejecter)
+                case .Fulfilled(let value):
+                    fulfiller(value.unwrap)
+                case .Rejected(let reason):
+                    rejecter(reason)
                 }
             }
         }

                        }
                        return reasonResult
                    }
                ))
            }
        default:
            return

    }
    
    private init(parent: () -> Any, synchronizationQueue: DispatchQueue, resolver: (Result<T> -> ()) -> ()) {
        self.state = .Pending(PendingInfo(parent: parent))
        self.synchronizationQueue = synchronizationQueue
        
        let weakResolve: Result<T> -> () = { [weak self] result in
