Exploring error patterns in swift

error.swift

enum Fallible<T> {
    case Error(NSError)
    case Some(T)
    
    init(value: T) {
        self = .Some(value)
    }
    
    init(error: NSError) {
        self = .Error(error)
    }
}

func function1(#fail: Bool) -> (value: String?, error: NSError?) {
    if (fail) {
        return (nil, NSError(domain: "foo", code: 0, userInfo: nil))
    }
    else {
        return ("Did not fail", nil)
    }
}

func function2(#fail: Bool) -> Fallible<String> {
    if (fail) {
        return Fallible(error: NSError(domain: "foo", code: 0, userInfo: nil))
    }
    else {
        return Fallible(value: "Did not fail")
    }
}

func try<T>(try: ()->Fallible<T>, #success:T->(), #failure: NSError->()) {
    let result = try()
    switch(result) {
    case let .Failure(error):
        failure(error)
    case let .Success(value):
        success(value)
    }
}

let attempt: ()->Fallible<String> = {
    let error = NSError(domain: "foo", code: 0, userInfo: nil)
    return Fallible(error: error)
}

let success : (String)->() = { s in println(s) }
let failure: (NSError)->() = { e in println("Error: \(e)") }

try(attempt, success: success, failure: failure)