{"id":11515,"date":"2015-06-19T11:12:08","date_gmt":"2015-06-19T15:12:08","guid":{"rendered":"http:\/\/mjtsai.com\/blog\/?p=11515"},"modified":"2019-03-13T15:21:22","modified_gmt":"2019-03-13T19:21:22","slug":"swift-2-error-handling-continued","status":"publish","type":"post","link":"https:\/\/mjtsai.com\/blog\/2015\/06\/19\/swift-2-error-handling-continued\/","title":{"rendered":"Swift 2 Error Handling, Continued"},"content":{"rendered":"

Mikael Konradsson<\/a>:<\/p>\n

Finally a [decent] exception model in a modern language, a model where it’s absolutely obvious when to use do\/try\/catch<\/code>. If you miss it, the compiler (precompiler\/static analyzer) will tell you. There is no, or very little overhead in using Exceptions in Swift, unlike Java and C# where the runtime must create the exception and unwind the stack and then throw.<\/p><\/blockquote>\n\n

Clark Goble<\/a>:<\/p>\n

My own view is that people are perhaps taking things too seriously. Swift is a very pragmatic language and it’s developing with a set of practical concerns. Mainly the connection to ObjC based Cocoa libraries. Maybe that’s undermining what the language could<\/em> be. But especially for the next years, the primary purpose of Swift will be to code against Cocoa. For all the problems and limits of Swift exceptions, they do seem a big step up from difficult to read nested if statements. Maybe this decision will limit Swift in the future. But in the present it’ll make most people’s life easier.<\/p><\/blockquote>\n\n

Paul Hudson<\/a>:<\/p>\n

This does have one downside: if you add any future values to the enum, which we’re about to do, it will just drop into the default catch<\/code> block – you won’t be asked to provide any code for it as would happen with a switch\/case<\/code> block.<\/p><\/blockquote>\n\n

David Owens II<\/a>:<\/p>\n

The latest thing I’m running up against in the cumbersomeness of the do-catch<\/code> pattern for handling errors. Not only that, I think it promotes the bad exception handling that Java had with people simply writing a single catch (Exception e)<\/code> handler.<\/p><\/blockquote>\n\n

Paul Hudson<\/a>:<\/p>\n

Swift 2 introduces the defer<\/code> keyword, which effectively means “here’s some what I want you to do later, no matter what.” That work can be whatever you want: a single method call closing a file, or 50 lines of code doing some other important clean up work. The important thing is that Swift ensures that it will be run before the current scope is ended.<\/p>\n

[…]<\/p>\n

One of the most powerful features of defer<\/code> is that you can stack up multiple deferred pieces of work, and Swift will ensure they all get executed. What’s more, it executes them in reverse order, meaning that the most recently deferred thing gets run first – effectively unwinding a stack.<\/p><\/blockquote>\n\n

Nick Lockwood<\/a> on Brad Larson’s post<\/a>:<\/p>\n

If you look at the examples in that article, the reason why the result enum doesn’t work well for him is that the methods being called are primarily synchronous, and without return values. They aren’t pure functions. […] But does that mean result types are bad? No, they’re pretty awesome for functions that actually return a result that we want to pass to the next function (possibly an unspecified amount of time later). They just aren’t great for handling errors produced by procedures that don’t return anything, and execute sequentially on the same thread, because they must be checked after every call, and that quickly becomes tedious.<\/p>\n

[…]<\/p>\n

But try<\/code> only works in this one situation, with sequential imperative statements. If Brad Larson was working on something like a network library instead of a robot controller, result types would work much better for error propagation than Swift 2’s exceptions, because exception-style errors don’t really work for asynchronous, callback-based APIs.<\/p>\n

[…]<\/p>\n

It’s gross that we have two totally different ways to handle errors based on whether the following line needs to use the output from the previous line, and whether it’s called immediately, or after an async calculation. And Swift’s try\/catch semantics do nothing to help reduce the error handling boilerplate needed inside callbacks.<\/p>\n<\/blockquote>\n\n

Rob Napier<\/a>:<\/p>\n

And “throws” is probably best thought of as somewhat opaque sugar around an Either type.<\/p>\n

[…]<\/p>\n

In fact, (Int) -> String<\/code> is a subtype<\/em> of (Int) throws -> String<\/code>, which is\npretty awesome and a little subtle, but we’ll get to that in another post.<\/p><\/blockquote>\n\n

Rob Napier<\/a>:<\/p>\n

So that tells us that a non-throwing closure can be used anywhere a throwing closure is requested, just like a Cat can be used anywhere an Animal is requested. No conversions necessary. It’s just types.<\/p>\n

[…]<\/p>\n

Luckily, Swift is much smarter than that. It’s nice that you can overload based\non throwing, but in many cases we have a better tool. We can mark the method\nrethrows<\/code> rather than throws<\/code>.<\/p>\n

func map<T>(@noescape transform: (Generator.Element) throws -> T) rethrows -> [T]<\/pre>\n
So what promise does rethrows<\/code> make? It promises that the only way it will\nthrow is if a closure it is passed throws. So if it’s passed a closure that\ncan’t throw, the compiler knows that the function can’t throw either.<\/p><\/blockquote>\n\n
Anthony Levings<\/a>:<\/p>\n
Internally the rethrowing function uses the try<\/code> keyword as usual, but does not require the do<\/code> and catch<\/code> elements. It is only when the function is called that the do-try-catch syntax is employed.<\/p><\/blockquote>\n\n
Erica Sadun<\/a>:<\/p>\n
If you’re working with asynchronous closures, you’ll need to supply ones that do not use throwing signatures. Convert your closures to non-throwing versions by providing exhaustive catch clauses.<\/p><\/blockquote>\n\n
Update (2015-06-22): Joshua Emmons<\/a>:<\/p>\n
It’s telling that exceptions have arrived in the language alongside multi-payload enums. This makes it trivial to create  Either<\/code> types without the awkward, inefficient boxing of values previously required. And it would seem exceptions take advantage of this. throws<\/code> is just syntactic sugar.<\/p><\/blockquote>\n\n
Update (2015-06-25): Juan Pablo Claude<\/a>:<\/p>\n
Swift 2.0 does a great job of coalescing the history of error handling in Cocoa and Cocoa Touch into a modern idiom that will feel familiar to many programmers. Unifying behavior leaves the Swift language and the frameworks it inherits in a good position to evolve.<\/p><\/blockquote>","protected":false},"excerpt":{"rendered":"
Mikael Konradsson: Finally a [decent] exception model in a modern language, a model where it’s absolutely obvious when to use do\/try\/catch. If you miss it, the compiler (precompiler\/static analyzer) will tell you. There is no, or very little overhead in using Exceptions in Swift, unlike Java and C# where the runtime must create the exception […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"apple_news_api_created_at":"2019-03-13T19:21:25Z","apple_news_api_id":"57986a52-3a37-4672-bb0f-4d3ee9f79964","apple_news_api_modified_at":"2019-03-13T19:21:27Z","apple_news_api_revision":"AAAAAAAAAAD\/\/\/\/\/\/\/\/\/\/w==","apple_news_api_share_url":"https:\/\/apple.news\/AV5hqUjo3RnK7D00-6feZZA","apple_news_coverimage":0,"apple_news_coverimage_caption":"","apple_news_is_hidden":false,"apple_news_is_paid":false,"apple_news_is_preview":false,"apple_news_is_sponsored":false,"apple_news_maturity_rating":"","apple_news_metadata":"\"\"","apple_news_pullquote":"","apple_news_pullquote_position":"","apple_news_slug":"","apple_news_sections":"\"\"","apple_news_suppress_video_url":false,"apple_news_use_image_component":false,"footnotes":""},"categories":[4],"tags":[69,79,31,46,30,857,71,901],"class_list":["post-11515","post","type-post","status-publish","format-standard","hentry","category-programming-category","tag-cocoa","tag-exceptions","tag-ios","tag-languagedesign","tag-mac","tag-nserror","tag-programming","tag-swift-programming-language"],"apple_news_notices":[],"_links":{"self":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts\/11515","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/comments?post=11515"}],"version-history":[{"count":5,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts\/11515\/revisions"}],"predecessor-version":[{"id":24592,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts\/11515\/revisions\/24592"}],"wp:attachment":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/media?parent=11515"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/categories?post=11515"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/tags?post=11515"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}