Swift 6のTyped throwsとSwiftにおけるエラーハンドリングの全体像を学ぶ

Swiftがオープンソースになって以来、長年議論され続けてきたTyped throwsの提案がついに承認されました。これは、throws節にエラー型を指定できる新しい言語機能であり、Swift 6から導入されます。

Swiftにおけるエラーハンドリングの考え方は、Swift 2でthrows/tryが導入される際にまとめられた"Error Handling Rationale and Proposal"というドキュメントに基づいています。その後、Swift 5でResultが導入され、Swift 5.5でSwift Concurrencyが追加されました。これにより、それらの機能とエラーハンドリングを併せて考える必要が生じました。そして、Swift 6でTyped throwsが導入されます。

しかし、それらの変化は、Swiftにおけるエラーハンドリングの基本的な考え方を変えるものではありません。"Error Handling Rationale and Proposal"の理念は今も生き続けています。

本セッションでは、まずTyped throwsについて説明し、次に"Error Handling Rationale and Proposal"の内容を復習します。最後に、それらを踏まえた上でSwift 6でどのようにエラーハンドリングを行うべきか、その全体像を示します。

iOSDC Japan 2024: レギュラートーク（40分）
https://fortee.jp/iosdc-japan-2024/proposal/c48577a8-33f1-4169-96a0-9866adc8db8e

Transcript

1. Swi$ 6ͷTyped throwsͱ Swi$ʹ͓͚ΔΤϥʔϋϯυϦϯά ͷશମ૾ΛֶͿ @koher
2. !LPIFS J04%$
   +BQBO
   ࢀՃྺ
   2016:
   ෆࢀՃ
   
   2017:
   ۩ମྫͱΫΠζͰֶͿɺ4XJGUͷछྨͷΤϥʔͷ࢖͍෼͚
   
   2018:
   J04ΤϯδχΞͷͨΊͷɺ4XJGU͔Β1ZUIPOͷϥΠϒϥϦΛ࢖ͬͯػցֶश͢Δํ๏
   
   2019:
   )FBSU
   PG
   4XJGU
   
   2020:
   ਓͰΞϓϦΛϦϑΝΫλϦϯάͯ͠ݟ͖͑ͯͨɺ࠷ڧͷJ04ΞϓϦઃܭʹٻΊΒΕΔ͜ͱ
   
   2021:
   BTZODBXBJU΍BDUPSͰJ04ΞϓϦ։ൃ͕Ͳ͏มΘΔ͔
   #FGPSF"GUFSͷ۩ମྫͰֶͿ
   
   2022:
   4XJGU
   $PODVSSFODZ࣌୅ͷJ04ΞϓϦͷ࡞Γํ
   
   2023:
   "*࣌୅ʹੜ͖ΔJ04ΤϯδχΞͷา͖ํ
   
   ⛔
   3FKFDUFE
   2024:
   4XJGU
   ͷ5ZQFE
   UISPXTͱ4XJGUʹ͓͚ΔΤϥʔϋϯυϦϯάͷશମ૾ΛֶͿ
   
   ˞
   ಺͸ఏग़ͨ͠ϓϩϙʔβϧͷ਺ʢ೥͸GPSUFFʹه࿥͕ͳ͘ਖ਼֬ͳ਺͸ෆ໌ʣ
3. Heart of Swift !LPIFS
4. ࠓ೔࿩͢಺༰ ! Typed throws ! Swi%ͷΤϥʔϋϯυϦϯάͷશମ૾
5. ! Typed Throws
6. SE-0413: Typed throws1 • Status: Implemented (Swi3 6.0) 1 h$ps:/ /github.com/swi3lang/swi3-evolu:on/blob/main/proposals/0413-typed-throws.md
7. Untyped throws func parseInt(_ value: String) throws -> Int
8. Untyped throws func parseInt(_ value: String) throws -> Int try parseInt("") // ۭจࣈྻ try parseInt("ABC") // ෆਖ਼ͳϑΥʔϚοτ try parseInt("9999999999999999999") // ൣғ֎
9. Untyped throws enum ParseError: Error { case emptyValue case illegalFormat(String) case outOfBounds(String) }
10. Untyped throws func parseInt(_ value: String) throws -> Int { if value.isEmpty { throw ParseError.emptyValue } guard let number = Int(value) else { if value.contains(/^[-]?\d+$/) { throw ParseError.outOfBounds(value) } else { throw ParseError.illegalFormat(value) } } return number }
11. Untyped throws do { let number = try parseInt(string) print(number) } catch { print(error) // any Error }
12. Untyped throws do { let number: Int = try parseInt(string) print(number) } catch let error as ParseError { switch error { // ParseError case .emptyValue: ... case .illegalFormat(let value): ... case .outOfBounds(let value): ... } }
13. ⛔ Errors thrown from here are not handled because the enclosing catch is not exhaus6ve
14. Untyped throws do { let number: Int = try parseInt(string) print(number) } catch let error as ParseError { switch error { // ParseError case .emptyValue: ... case .illegalFormat(let value): ... case .outOfBounds(let value): ... } }
15. Untyped throws do { let number: Int = try parseInt(string) print(number) } catch let error as ParseError { switch error { // ParseError case .emptyValue: ... case .illegalFormat(let value): ... case .outOfBounds(let value): ... } } catch { preconditionFailure("Never reaches here.") }
16. Untyped throws func parseInt(_ value: String) throws -> Int
17. Typed throws func parseInt(_ value: String) throws(ParseError) -> Int
18. Untyped throws do { let number = try parseInt(string) print(number) } catch { print(error) // any Error }
19. Typed throws do { let number = try parseInt(string) print(number) } catch { switch error { // ParseError ... } }
20. Untyped throws do { let number: Int = try parseInt(string) print(number) } catch let error as ParseError { switch error { // ParseError case .emptyValue: ... case .illegalFormat(let value): ... case .outOfBounds(let value): ... } } catch { preconditionFailure("Never reaches here.") }
21. Typed throws do { let number: Int = try parseInt(string) print(number) } catch { switch error { // ParseError case .emptyValue: ... case .illegalFormat(let value): ... case .outOfBounds(let value): ... } }
22. Typed throws͕΄͔ͬͨ͠ଞͷཧ༝ func foo() throws -> Int { // any Error let result: Result<Int, FooError> = ... switch result { case .success(let value): return value case .failure(let error): throw error // FooError } } • Result, Task ౳ͱͷม׵ͰΤϥʔͷܕ͕ࣦΘΕΔ
23. Typed throwsؔ࿈ͷߏจ౳
24. Typed throws throws(Τϥʔܕ) -> ໭Γ஋ܕ • () ͸ඞਢ • () ͷதʹΤϥʔܕ͸Ұ͔ͭ͠ॻ͚ͳ͍
25. SE-0413: Typed throws1 • Status: Implemented (Swi3 6.0) • Alterna:ves considered • Thrown error type syntax 1 h$ps:/ /github.com/swi3lang/swi3-evolu:on/blob/main/proposals/0413-typed-throws.md
26. ΋͠ () ͕ඞਢͰͳ͔ͬͨΒ func foo() throws (E) -> Int { ... } • ͲͪΒͱղऍ͢Ε͹ྑ͍͔ᐆດ • throws E • throws ((E) -> Int)
27. ΋͠ () ͕ඞਢͰͳ͔ͬͨΒ func foo() throws bar -> Int { ... } struct bar: Error {} • bar ͕ܕ͔effect͔۠ผͰ͖ͳ͍
28. SE-0413: Typed throws1 • Status: Implemented (Swi3 6.0) • Alterna:ves considered • Mul:ple thrown error types 1 h$ps:/ /github.com/swi3lang/swi3-evolu:on/blob/main/proposals/0413-typed-throws.md
29. ΋͠ () ͷதʹෳ਺ͷΤϥʔܕΛॻ͚ͨΒ func foo() throws(BarError, BazError) -> Int • BarError | BazError Λಋೖ͢Δͷͱಉ͡ • Typed throwsͷͨΊʹ΍Δʹ͸ܕγεςϜ΁ͷӨڹ͕େ͖͢ ͗Δ
30. ݸਓతʹ͸Τϥʔܕ͸ҰͭͰྑ͍ͱࢥ͏ • ΤϥʔܕΛෳ਺ࢦఆͰ͖Δͱɺ҆қʹԼ૚ͷΤϥʔΛͦͷ·· throw ͕ͪ͠ func foo() throws(IOError, NetworkError, ...) -> Int • Τϥʔͷܕ͕ҰͭͳΒɺͦͷؔ਺ʹͱͬͯͷΤϥʔͱ͸Կ͔Λ ߟ͑Δ͖͔͚ͬʹͳΔ • Լ૚ͷΤϥʔΛͦͷ·· throw ͢ΔͳΒ any Error Ͱྑ͍
31. Typed throws throws(Τϥʔܕ) -> ໭Γ஋ܕ • () ͸ඞਢ • () ͷதʹΤϥʔܕ͸Ұ͔ͭ͠ॻ͚ͳ͍
32. do do { let number = try parseInt(string) // ParseError print(number) } catch { // ParseError }
33. do do { let number = try parseInt(string) // ParseError try foo(number) // FooError } catch { // ??? }
34. do do { let number = try parseInt(string) // ParseError try foo(number) // FooError } catch { // any Error }
35. do throws do throws(ParseError) { let number = try parseInt(string) // ParseError try foo(number) // ⛔ FooError } catch { // ParseError }
36. throws(any Error) func foo() throws(any Error) -> Int
37. throws(any Error) func foo() throws(any Error) -> Int func foo() throws -> Int // ͜Εͱಉ͡
38. throws(Never) func foo() throws(Never) -> Int
39. throws(Never) func foo() throws(Never) -> Int func foo() -> Int // ͜Εͱಉ͡
40. Result.get // Swift 5 enum Result<Success, Failure: Error> { func get() throws -> Success }
41. Result.get // Swift 6 enum Result<Success, Failure: Error> { func get() throws(Failure) -> Success }
42. Result.get // Swift 5 let result: Result<Int, Never> = ... do { let value = try result.get() } catch { preconditionFailure("Never reaches here.") }
43. Result.get // Swift 6 let result: Result<Int, Never> = ... let value = result.get()
44. rethrows // try͕ෆཁ [2, 3, 5].map { $0 * $0 } // try͕ඞཁ try ["2", "3", "5"].map { try parseInt($0) }
45. rethrows extension Sequence { func map<T>( _ transform: (Element) throws -> T ) rethrows -> [T] }
46. rethrows extension Sequence { func map<T>( _ transform: (Element) throws -> T ) rethrows -> [T] // rethrows͸↓ͷೋͭͱಉ͡Α͏ͳ΋ͷ func map<T>(_ transform: (Element) -> T) -> [T] func map<T>( _ transform: (Element) throws -> T ) throws -> [T] }
47. rethrows // try͕ෆཁ [2, 3, 5].map { $0 * $0 } // try͕ඞཁ try ["2", "3", "5"].map { try parseInt($0) }
48. rethrows extension Sequence { func map<T>( _ transform: (Element) throws -> T ) rethrows -> [T] }
49. Typed throwsʹΑΔ rethrows extension Sequence { func map<T, E: Error>( _ transform: (Element) throws(E) -> T ) throws(E) -> [T] }
50. Typed throws͸҆қʹ࢖͏΂͖Ͱ͸ͳ͍
51. SE-0413: Typed throws1 • Status: Implemented (Swi3 6.0) • When to use typed throws • Typed throwsΛ҆қʹ࢖͏΂͖Ͱͳ͍ཧ༝ • Ͳ͏͍͏ͱ͖ʹTyped throwsΛ࢖͏΂͖͔ 1 h$ps:/ /github.com/swi3lang/swi3-evolu:on/blob/main/proposals/0413-typed-throws.md
52. Typed throwsΛ҆қʹ࢖͏΂͖Ͱͳ͍ཧ༝ • Τϥʔͷܕ͸มԽ͠΍͍͢ • Τϥʔ͕໢ཏతʹϋϯυϦϯά͞ΕΔ͜ͱ͸গͳ͍
53. Ͳ͏͍͏ͱ͖ʹTyped throwsΛ࢖͏΂͖͔ • Ϟδϡʔϧ΍ύοέʔδͷதʹดͯ͡ΤϥʔϋϯυϦϯά͢Δ Α͏ͳ৔߹ • map ͷ rethrows ΍ Result ͷΑ͏ʹͦΕࣗମ͕ΤϥʔΛੜΈ ग़͞ͳ͍৔߹ • Existen*al͕࢖͑ͳ͍ʗΦʔόʔϔου͕ڐ༰Ͱ͖ͳ͍৔߹
54. Resist the tempta+on to use typed throws1 Typed throwsΛ࢖͏༠࿭ʹ఍߅͍ͯͩ͘͠͞ 1 h$ps:/ /github.com/swi3lang/swi3-evolu:on/blob/main/proposals/0413-typed-throws.md
55. Even with the introduc/on of typed throws into Swi5, the exis/ng (untyped) throws remains the be>er default error-handling mechanism for most Swi5 code.1 typed throws͕Swi.ʹಋೖ͞Εͨͱͯ͠΋ɺطଘͷʢuntypedʣ throws͸ɺ΄ͱΜͲͷSwi.ίʔυʹ͓͍ͯɺґવͱͯ͠ΑΓྑ͍ σϑΥϧτͷΤϥʔϋϯυϦϯάϝΧχζϜͰ͢ɻ 1 h$ps:/ /github.com/swi3lang/swi3-evolu:on/blob/main/proposals/0413-typed-throws.md
56. ݸਓతʹ͸Ϟδϡʔϧ΍ύοέʔδΛӽ͑ͯྑ͍ͱࢥ͏ • ϞϊϨϙͳͲίʔυ͕Ұମͱͯ͠؅ཧ͞Ε͍ͯΔͱ͖ • Ҿ਺΍໭Γ஋ͷܕͱಉఔ౓ͷස౓Ͱ͔͠Τϥʔܕͷมߋ͕ى͜ Βͳ͍ͱ͖ • Result ͷ Failure ͱมΘΒͳ͍
57. ͱ͸͍͑ɺTyped Throws͕׆͖Δέʔε͸ݶఆత • async ͷͱ͖͸࢖͍ͮΒ͍ • CancellationError ͱͲ͏ڞଘ͢Δʁ
58. Typed throwsͷΞϯνύλʔϯ enum AppError { case network(NetworkError) case server(ServerError) case cancellation(CancellationError) } • ⛔ Typed throwsʹ͢ΔͨΊʹ CancellationError Λ case ʹՃ͑ΔͳͲɺSwi0ͷඪ४తͳΤϥʔϋϯυϦϯάͷ׳ྫͱઓ ͏
59. Typed throwsͷΞϯνύλʔϯ func foo() throws { // any Error try bar() // AppError try baz() // OtherError } do { try foo() } catch is CancellationError { // Ωϟϯηϧ͞Εͨ৔߹ͷॲཧ } catch { // ⛔ AppError.calcellation͕ͬͪ͜ʹؚ·ΕΔ }
60. ! Swi%ͷΤϥʔϋϯυϦϯάͷ શମ૾
61. Error Handling Ra-onale and Proposal5 • Kinds of error • Propaga0on 5 h$ps:/ /github.com/swi3lang/swi3/blob/main/docs/ErrorHandlingRa<onale.md
62. Kinds of error • Simple domain errors • Recoverable errors • Universal errors • Logic failures
63. Simple domain errors guard let number = Int(string) else { // ΤϥʔϋϯυϦϯά } • ൃੜ৚͕݅໌֬Ͱ͙͢ʹϋϯυϦϯά͞ΕΔΑ͏ͳΤϥʔ • Τϥʔͷཧ༝͕໌֬ͳͷͰ nil Ͱද͞ΕΔ • ͙͢ʹϋϯυϦϯά͠ͳ͍ͱݪҼෆ໌ʹ • ϋϯυϦϯά͸৚݅෼ذͰे෼
64. Simple domain errors guard let last = array.popLast() else { // ΤϥʔϋϯυϦϯά } guard let max = array.max() else { // ΤϥʔϋϯυϦϯά }
65. Recoverable errors do { try data.write(to: url, options: .atomic) } catch { // ΤϥʔϋϯυϦϯά } • ݪҼ͕ଟذʹ౉ΔΤϥʔͰ Error Ͱද͞ΕΔ • ద੾ͳ৔ॴ·ͰΤϥʔΛ఻೻ͤ͞ݪҼʹԠͯ͡ϋϯυϦϯά • ઐ༻ͷߏจʢ throws ΍ do/try/catch ʣ͕΄͍͠
66. Universal errors Array(repeating: 42, count: .max) // Out of memory • ݪҼͱͳΔՕॴ͕ଟ༷Ͱ͋ΒΏΔՕॴͰى͜ΓಘΔΤϥʔ • ϓϩηεͷதஅɾϝϞϦෆ଍ɾελοΫΦʔόʔϑϩʔͳͲ • ݱঢ়Ͱ͸ඪ४తͳํ๏ͰϋϯυϦϯά͢Δ͜ͱ͸Ͱ͖ͳ͍
67. Logic failures nilValue! // Unexpectedly found nil while unwrapping array[-1] // Index out of bounds Int.max + 1 // Overflow • ίʔυͷޡΓ͕ݪҼͰൃੜ͢ΔΤϥʔ • Forced unwrappingͷࣦഊɾΠϯσοΫεൣғ֎ɾ੔਺ͷΦʔ όʔϑϩʔͳͲͷࣄલ৚݅ҧ൓ͳͲ • ಈతʹϋϯυϦϯά͢ΔͷͰ͸ͳ͘ίʔυΛमਖ਼ͯ͠ରԠ
68. Logic failures func foo(length: Int) { precondition(length >= 0) ... }
69. Logic failures do { let number: Int = try parseInt(string) print(number) } catch let error as ParseError { switch error { // ParseError case .emptyValue: ... case .illegalFormat(let value): ... case .outOfBounds(let value): ... } } catch { preconditionFailure("Never reaches here.") }
70. Simple domain errors / Recoverable errors vs Logic failures
71. Simple domain errors vs Logic failures // Simple domain errors dictionary[key] // ࣦഊ͢Δͱnil // Logic failures array[i] // ࣦഊ͢Δͱ࣮ߦ࣌Τϥʔ
72. Ͳ͏ͯ͠ array[i] ͸ ൣғ֎ͷͱ͖ʹ nil Λฦ͞ͳ͍ͷ͔ʁ
73. array[i] ͕ൣғ֎ʹͳΔଟ͘ͷέʔε͸ίʔυͷޡΓ // i, j͕ൣғ֎ʹͳͬͨ͜ͱ͕Θ͔ͬͯ΋࣮ߦ࣌ʹͰ͖Δ͜ͱ͸ͳ͍ func sort(_ array: inout [Int]) { for i in 0 ..< array.count { for j in i + 1 ..< array.count { if array[j] < array[i] { let t = array[j] array[j] = array[i] array[i] = t } } } }
74. Logic failureͰྑ͍΋ͷΛ Logic failureͱͯ͠ѻ͏͜ͱ͕ॏཁ ʢRecoverableʹ͠ͳ͍ʣ
75. optional! ΋ array[i] ΋มΘΒͳ͍ • ͲͪΒ΋Logic failure • Forced unwrappingΛઈରʹආ͚ΔͳΒ array[i] ΋ආ͚ͳ͍ ͱ੔߹ੑ͕औΕͳ͍
76. optional! ΋ array[i] ΋มΘΒͳ͍ let value = Int(string)!
77. optional! ΋ array[i] ΋มΘΒͳ͍ guard let value = Int(string) else { predonditionFailure(...) }
78. optional! ΋ array[i] ΋มΘΒͳ͍ let value = array[0]
79. optional! ΋ array[i] ΋มΘΒͳ͍ guard let value = array.first else { predonditionFailure(...) }
80. Kinds of error • Simple domain errors • Recoverable errors • Universal errors • Logic failures
81. Propaga'on • Manual propaga,on • Automa,c propaga,on
82. Manual propaga+on func foo() -> Foo? { ... guard let value = Int(string) else { return nil // manual } ... }
83. Manual propaga+on func foo() -> Result<Foo, any Error> { ... switch result { case .success(let value): ... case .failure(let error): return .failure(error) // manual } ... }
84. Automa'c propaga'on func foo() throws -> Foo { ... let value = try bar() ... }
85. Automa'c propaga'on func foo(x: Int, y: Int) throws -> Int { let a = try bar(x) let b = try baz(y) return a + b }
86. Manual propaga+on func foo(x: Int, y: Int) -> Result<Foo, any Error> { bar(x).flatMap { a in baz(y).map { b in a + b } } }
87. ؔ਺ܕϓϩάϥϛϯάͷख๏͕͋Ε͹ Automa'c propaga'on͸ཁΒͳ͍ʁ
88. HaskellͰ͢Β do ه๏Λఏڙ͍ͯ͠Δ
89. do ه๏ foo :: Int -> Int -> Either FooError Int foo x y = do a <- bar x b <- baz y return (a + b)
90. do ه๏͕ͳ͍ͷʹؔ਺ܕͷख๏Ͱ͕Μ͹Δͱ ίʔυͷϊΠζ͕૿͑Δ
91. Swi$ͷΤϥʔϋϯυϦϯά Kind \ Propaga-on Manual Automa-c Simple domain Optional - Recoverable Result throws Universal - Ϋϥογϡ Logic - Ϋϥογϡ
92. ΤϥʔͷݪҼ͸όά ʢίʔυΛमਖ਼͢΂͖໰୊ʣ ΤϥʔͷݪҼ͕໌֬ͰҰ͚ͭͩ ʢݪҼผʹ෼ذ͕ඞཁͳ͍ʣ ΤϥʔͷܕΛࢦఆ͍ͨ͠ ※ ຊ౰ʹඞཁ͔ཁݕ౼ Logic failure precondition౳ Simple domain error Optional ΤϥʔͷܕΛݶఆͯ͠ྑ͍৚݅Λ ຬͨ͢ ΤϥʔΛม਺౳Ͱѻ͏ඞཁ͕͋Δ ※ ຊ౰ʹඞཁ͔ཁݕ౼ ΤϥʔΛม਺౳Ͱѻ͏ඞཁ͕͋Δ ※ ຊ౰ʹඞཁ͔ཁݕ౼ Recoverable / Automatic / Typed throws(FooError) Recoverable / Manual / Typed Result<Foo, FooError> Recoverable / Manual / Untyped Result<Foo, any Error> Recoverable / Automatic / Untyped throws YES NO ΤϥʔͷܕΛݶఆͯ͠ྑ͍৚݅ • Ϟδϡʔϧ΍ύοέʔδͷதʹดͯ͡Τϥʔ ϋϯυϦϯά͢ΔΑ͏ͳ৔߹ • map ͷ rethrows ΍ Result ͷΑ͏ʹͦΕ ࣗମ͕ΤϥʔΛੜΈग़͞ͳ͍৔߹ • Existential͕࢖͑ͳ͍ʗΦʔόʔϔου͕ڐ༰ Ͱ͖ͳ͍৔߹
93. ·ͱΊ • Typed throws͸ΤϥʔͷܕΛࢦఆͰ͖ͯศར • ͚Ͳɺ࢖͍Ͳ͜Ζ͸ݶΒΕ͍ͯΔ • throws ͸Recoverable error • ΤϥʔͷछྨΛҙࣝͯ͠࢖͍෼͚Δ