A result enum, storing a boxed type or a NSError meant to be return from any process (API call, etc) (Swift 1.2)

Result.swift

// MARK: - Box

final public class Box<T> {
    public let unbox:T
    public init(_ value: T) { self.unbox = value }
}

// MARK: - Result enum

public enum Result<T: Printable> {
    
    case Success(Box<T>)
    case Failure(NSError)
    case Pending
    
    public init(_ value: T) {
        self = .Success(Box(value))
    }
    
    public init(_ error: NSError) {
        self = .Failure(error)
    }
    
    public var value: T? {
        switch self {
        case .Success(let value): return value.unbox
        default: return nil
        }
    }
    
    public func transform<P>(f: T -> Result<P>) -> Result<P> {
        switch self {
        case Success(let value): return f(value.unbox)
        case Failure(let error): return .Failure(error)
        case Pending: return .Pending
        }
    }
    
    public func transform<P>(f: T-> Result<P>, queue: dispatch_queue_t, completion: Result<P> -> Void) {
        switch self {
        case .Success(let value):
            dispatch_async(queue, { () -> Void in
                let result = f(value.unbox)
                dispatch_async(dispatch_get_main_queue()) { () -> Void in
                    completion(result)
                }
            })
        case Failure(let error): completion(.Failure(error))
        case Pending: completion(.Pending)
        }
    }
}

extension Result: Printable, DebugPrintable {
    
    public var description: String {
        switch self {
        case .Success(let value): return value.unbox.description
        case .Failure(let error): return error.description
        case .Pending: return "Pending"
        }
    }
    
    public var debugDescription: String { return self.description }
}