//エラーを列挙型で定義
enum SomeError: Error {
    case error1
    //列挙型のケースの連想値を利用することで、エラーに付随する情報を表現することもできます。
    case error2(reason: String)
}

do {
    //throw文によるエラーが発生する可能性のある処理
    throw SomeError.error2(reason: "何かがおかしいようです")//Errorプロトコルに準拠した値
} catch SomeError.error1 {
    //エラー処理
    print("error1")
} catch SomeError.error2(let reason) {
    //エラー処理
    print("error2: \(reason)")
} catch { //パターンの指定がないcatch節はすべてのエラーにマッチ
    //エラー処理
    print("Unknown error: \(error)")
}

//実行結果
//error2: 何かがおかしいようです

enum OperationError : Error {
    case overCapacity
}

//throwsキーワードを持つ関数
func sam(_ int: Int) throws -> Int {
    guard int < 10 else {
        //do-catch文を用いずにthrow文によるエラーを発生させる
        throw OperationError.overCapacity
    }
    return int
}

//関数の呼び出し時にdo-catch文を使用
do {
    try sam(11)
} catch OperationError.overCapacity {
    print("数値が大き過ぎます")
}

//実行結果
//数値が大き過ぎます

enum SamError: Error {
    case overCapacity(str:String)
}

struct Sam {
    let a: Int
    
    init(_ arg: Int) throws {
        guard case 13...19 = arg else {
            throw SamError.overCapacity(str: "数値が範囲外です")
        }
        
        self.a = arg
    }
}

do {
    try Sam(10)
} catch SamError.overCapacity(let str) {
    print(str)
}

//実行結果
//数値が範囲外です

enum CutomErr: Error {
    case err1(str:String)
}

func sam(a:Int, handler: (Int) throws -> Int){
    do {
        try handler(a)
    } catch CutomErr.err1(let a) {
        print(a)
    }catch{
        
    }
}

sam(a:2){b throws -> Int in
    if b<10 {
        throw CutomErr.err1(str: "値が小さいです。")
    }
    return b*10
}

//値が小さいです。

enum SomeError: Error {
    case err1(str:String)
}

//関数はrethrowsキーワードを用いて定義されているので、
//クロージャが発生させるエラーの処理を関数の呼び出し元に任せることができます。
func samFunction(_ closure: () throws -> Void) rethrows {
    //エラーを発生させるクロージャを引数にとり実行
    try closure()
}

do {
    try samFunction{()->Void in
        throw SomeError.err1(str:"SomeError")
    }
} catch SomeError.err1(let str) {
    // 引数のクロージャが発生させるエラーを、関数の呼び出し元で処理
    print(str) // SomeError
}

enum SomeError: Error {
    case err1
    case err2
}

func samFunction(_ closure: () throws -> Void) rethrows {
    do {
        try closure() //エラー（SomeError.err2）が発生
    } catch {
        //上記でエラーが発生したので下記（エラーSomeError.err1が発生）が実行される
        throw SomeError.err1
    }
}

do {
    try samFunction{()->Void in
        throw SomeError.err2
    }
    //関数samFunctionを実行した結果エラー（SomeError.err1）が発生
} catch {
    //発生したエラーはSomeError.err1になる
    error //err1
}

enum SamError : Error {
    case overCapacity
}

//戻り値がInt.maxを超えてしまう可能性があるため、超えてしまった場合はエラーを発生させる
func sam(_ int: Int) throws -> Int {
    guard int <= Int.max / 3 else {
        throw SamError.overCapacity
    }
    
    return int * 10
}

//引数に9を与えているためエラーが発生しないことは明らかなためtry!キーワードを使用して、
//エラー処理を実装せずに関数を呼び出しています。
let tripleOfInt = try! sam(9) // do-catch文なしで実行可能
print(tripleOfInt) //90

enum SamError : Error {
    case overCapacity
}

//戻り値がInt.maxを超えてしまう可能性があるため、超えてしまった場合はエラーを発生させる
func sam(_ int: Int) throws -> Int {
    guard int <= Int.max / 3 else {
        throw SamError.overCapacity
    }
    
    return int * 10
}

//引数に9を与えているためエラーが発生しないことは明らかなためtry?キーワードを使用して、
//エラー処理を実装せずに関数を呼び出しています。
if let val = try? sam(9){ // do-catch文なしで実行可能
    print(val) //90
}

//“関数の戻り値はOptional<Wrapped>型
print(try? sam(9)) //Optional(90)

enum SamError: Error {
    case outOfRange
}

struct Sam {
    let val: Int
    
    init(_ val: Int) throws {
        guard case 13...19 = val else {
            throw SamError.outOfRange
        }
        
        self.val = val
    }
}

if let a = try? Sam(17) {
    print(a) //Sam(val: 17)
}