Future.swift

import Foundation

public struct Future<T> {
    public let onFail: (() -> ()) -> Future<T>
    public let onSuccess: (T -> ()) -> Future<T>
}

public class Promise<T> {
    private var onFails = [] as [() -> ()]
    private var onSuccesses = [] as [T -> ()]
    
    private var result: T?
    private var isResolved = false
    
    public var future: Future<T> {
        return Future(onFail: self.onFail, onSuccess: self.onSuccess)
    }
    
    private func onFail(cb: () -> ()) -> Future<T> {
        guard !isResolved else {
            if result == nil { cb() }
            return self.future
        }
        
        onFails.append(cb)
        return self.future
    }
    
    private func onSuccess(cb: T -> ()) -> Future<T>  {
        guard !isResolved else {
            if let result = result { cb(result) }
            return self.future
        }
        
        onSuccesses.append(cb)
        return self.future
    }
    
    public func resolve(value: T) -> Future<T> {
        precondition(!isResolved)
        precondition(result == nil)
        
        result = value
        isResolved = true
        onSuccesses.forEach { $0(value) }
        
        return self.future
    }
    
    public func fail() -> Future<T> {
        precondition(!isResolved)
        precondition(result == nil)
        
        isResolved = true
        onFails.forEach { $0() }
        
        return self.future
    }
    
    public init() {}
}