NSErrorConvertible

protocol NSErrorConvertible {
    var domain: String { get }
    var code: Int { get }
    var userInfo: [NSObject: AnyObject]? { get }
}

extension NSError {
    convenience init(_ error: NSErrorConvertible) {
        self.init(domain: error.domain, code: error.code, userInfo: error.userInfo)
    }
}

protocol MyErrorType: ErrorType, NSErrorConvertible, CustomStringConvertible {
}

extension MyErrorType {
    // NSErrorConvertible
    var domain: String {
        return "MyErrorDomain"
    }
    var code: Int {
        return 0
    }
    var userInfo: [NSObject: AnyObject]? {
        return [NSLocalizedDescriptionKey: description]
    }
    // CustomStringConvertible
    var description: String {
        return "Unexpected MyError"
    }
}

class Simple {
    enum Error: MyErrorType {
        case foo, bar, baz
    }
}

class Foo {
    enum Error: Int, MyErrorType {  // Code is important.
        case foo = 100
        case bar = 200
        var domain: String { return "FooError" }
        var code: Int { return self.rawValue }
    }
}

class Bar {
    enum Error: String, MyErrorType {  // Description is important.
        case foo = "Foo error"
        case bar = "Bar error"
        var domain: String { return "BarError" }
        var description: String { return self.rawValue }
    }
}

class Baz {
    enum Error: MyErrorType {
        case foo
        case bar
        case baz(String)
        
        // NSErrorConvertible
        var domain: String { return "BazError" }
        var code: Int {
            switch self {
            case .foo: return 100
            case .bar: return 200
            case .baz: return 300
            }
        }
        var userInfo: [NSObject: AnyObject]? {
            var info = [NSLocalizedDescriptionKey: description]
            switch self {
            case .foo: info["foo"] = "foooooo"
            case .bar: info["bar"] = "baaaaaarr"
            case .baz(let s): info["baz"] = "bazzzzzzzz \(s)"
            }
            return info
        }
        // CustomStringConvertible
        var description: String {
            switch self {
            case .foo: return "foo error"
            case .bar: return "bar error"
            case .baz(let s): return "baz error \(s)"
            }
        }
    }
}

NSError(Simple.Error.foo)
NSError(Simple.Error.bar)

NSError(Foo.Error.foo)
NSError(Foo.Error.bar)

NSError(Bar.Error.foo)
NSError(Bar.Error.bar)

NSError(Baz.Error.foo)
NSError(Baz.Error.bar)
NSError(Baz.Error.baz("darn"))