Typing the throwable errors

Catch.swift

func catchAll(name: String?) {
  do {
    try throwSomething(name)
  } catch {
    print("An error occured")
  }
}

func catchAllWithReference(name: String?) {
  do {
    try throwSomething(name)
  } catch let error {
    print("This error occured: \(error)") 
  }
}

func catchNameError(name: String?) {
  do {
    try throwSomething(name)
  } catch is NameError {
    print("A NameError occured")
  } catch {
    print("An Error occured")
  }
}

func catchNameErrorWithReference(name: String?) {
  do {
    try throwSomething(name)
  } catch let error where error is NameError {
    print("A NameError occured: \(error)")
  } catch {
    print("An Error occured")
  }
}

func catchNameErrorMessages(name: String?) {
  do {
    try throwSomething(name)
  } catch let NameError.Nil(message) {
    print(message)
  } catch let NameError.Wrong(message) {
    print(message)
  } catch {
    print("An Error occured")
  }
}

NameError.swift

enum NameError: ErrorType {
  case Nil(String)
  case Wrong(String)
  
  init?(name: String?) {
    switch name {
      case .None:
        self = .Nil("can't be nil")
      case let .Some(name) where name == "damien":
        self = .Wrong("can't be damien")
      default:
        return nil
    }
  }
}

func throwSomething(name: String?) throws {
  if let error = NameError(name: name) {
    throw error
  }
}

let names: [String?] = [nil, "damien", "sophie"]

for name in names {
  catchAll(name)
  catchAllWithReference(name)
  catchNameError(name)
  catchNameErrorWithReference(name)
  catchNameErrorMessages(name)
}

Whish.swift

func throwSomething(name: String?) throws(NameError) {
  if let error = NameError(name: name) {
    throw error
  }
}

do {
  try throwSomething(nil)
} catch let .Nil(message) {
  print(message)
} catch let .Wrong(message) {
  print(message)
}