<html><head><meta http-equiv="Content-Type" content="text/html charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><br class=""><div><blockquote type="cite" class=""><div class="">On Jun 29, 2017, at 1:05 AM, David Hart via swift-evolution <<a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><meta http-equiv="Content-Type" content="text/html charset=utf-8" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">I’ve taken time to digest all the messages on this discussion and would like to summarise my point of view concerning several topics:</div><div class=""><br class=""></div><div class=""><div class=""><b class="">Usefulness of messages</b></div><div class=""><br class=""></div><div class="">Xiaodi seems to question the usefulness of attaching more information to the failure case of an optional's unwrapping. To his credit, the original example ("Array guaranteed non-empty") don’t add much. Instead, I think we should see those strings as a great opportunity to add application-specific business logic context that help debugging when the unwrapping fails. For example, let’s imagine that I am handling the log out operation for a user I know exists, I could write this:</div><div class=""><br class=""></div><div class=""><font face="Menlo" class="">let user = database.users[userId] !! “User to logout does not exist”</font></div></div></div></div></blockquote><div><br class=""></div><div>To expand on the usefulness of these messages, here’re some scattered examples of how I’ve been using this operator in an app I work on, pulled from various parts of the code:</div><div><br class=""></div><div>// in a right-click gesture recognizer action handler</div><div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; color: rgb(209, 47, 27); background-color: rgb(255, 255, 255);" class=""><span style="color: #ba2da2" class="">let</span><span style="color: #000000" class=""> event = </span><span style="color: #703daa" class="">NSApp</span><span style="color: #000000" class="">.currentEvent !! </span>"Trying to get current event for right click, but there's no event”</div></div><div><br class=""></div><div>// in a custom view controller subclass that only accepts children of a certain kind:</div><div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; color: rgb(209, 47, 27); background-color: rgb(255, 255, 255);" class=""><span style="color: #ba2da2" class="">let</span><span style="color: #000000" class=""> existing = childViewControllers </span><span style="color: #ba2da2" class="">as</span><span style="color: #000000" class="">? </span><span style="color: #703daa" class="">Array</span><span style="color: #000000" class=""><</span><span style="color: #703daa" class="">TableRowViewController</span><span style="color: #000000" class="">> !! </span>"TableViewController must only have TableRowViewControllers as children"</div></div><div><br class=""></div><div>// providing a value based on an initializer that returns an optional:</div><div><div style="margin: 0px; line-height: normal; background-color: rgb(255, 255, 255);" class=""><font color="#ba2da2" face="Menlo" class=""><span style="font-size: 11px;" class="">lazy var</span></font><font face="Menlo" class=""><span style="font-size: 11px;" class=""> emptyURL: </span></font><span style="font-family: Menlo; font-size: 11px; color: rgb(112, 61, 170);" class="">URL</span><font face="Menlo" class=""><span style="font-size: 11px;" class=""> = { </span></font><span style="font-family: Menlo; font-size: 11px; color: rgb(186, 45, 162);" class="">return</span><font face="Menlo" class=""><span style="font-size: 11px;" class=""> URL(string: </span></font><font color="#d12f1b" face="Menlo" class=""><span style="font-size: 11px;" class="">“<a href="myapp://section/" class="">myapp://section/</a></span></font><font face="Menlo" class=""><span style="font-size: 11px;" class="">\</span></font><span style="font-family: Menlo; font-size: 11px; color: rgb(209, 47, 27);" class="">(</span><font face="Menlo" class=""><span style="font-size: 11px;" class="">identifier</span></font><span style="font-family: Menlo; font-size: 11px; color: rgb(209, 47, 27);" class="">)"</span><font face="Menlo" class=""><span style="font-size: 11px;" class="">) !! </span></font><font color="#d12f1b" face="Menlo" class=""><span style="font-size: 11px;" class="">"can't create basic empty url” </span></font><span style="font-family: Menlo; font-size: 11px;" class="">}()</span></div></div><div><br class=""></div><div>// retrieving an image from an embedded framework:</div><div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""> <span style="color: #ba2da2" class="">private</span> <span style="color: #ba2da2" class="">static</span> <span style="color: #ba2da2" class="">let</span> addImage: <span style="color: #703daa" class="">NSImage</span> = {</div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""> <span style="color: #ba2da2" class="">let</span> bundle = <span style="color: #703daa" class="">Bundle</span>(for: <span style="color: #4f8187" class="">FlagViewController</span>.<span style="color: #ba2da2" class="">self</span>)</div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""> <span style="color: #ba2da2" class="">let</span> image = bundle.image(forResource: <span style="color: #d12f1b" class="">"add"</span>) !! <span style="color: #d12f1b" class="">"Missing 'add' image"</span></div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""> image.isTemplate = <span style="color: #ba2da2" class="">true</span></div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""> <span style="color: #ba2da2" class="">return</span> image</div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""> }()</div></div><div><br class=""></div><div>// asserting consistency of an internal model</div><div><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo; background-color: rgb(255, 255, 255);" class=""><span style="color: #ba2da2" class="">let</span> flag = command.flag(with: flagID) !! <span style="color: #d12f1b" class="">"Unable to retrieve non-custom flag for id </span>\<span style="color: #d12f1b" class="">(</span>flagID.string<span style="color: #d12f1b" class="">)"</span></div></div><div><br class=""></div><div>My usage of “!!” generally falls in to two big buckets:</div><div><br class=""></div><div>1. Asserting system framework correctness</div><div><br class=""></div><div><span class="Apple-tab-span" style="white-space:pre"> </span>For example, the “NSApp.currentEvent” property returns an Optional<NSEvent>, because there’s not always a current event going on. That’s fine. But when I’m in the action handler of a right-click gesture recognizer it is safe to assert that I do have an event. If this ever fails, I have an immediately clear description of where the system framework has not worked according to my expectations.</div><div><br class=""></div><div>2. Asserting app logic correctness</div><div><br class=""></div><div><span class="Apple-tab-span" style="white-space:pre"> </span>For example, I use this to assert that my outlets are properly hooked up (and the message tells me explicitly which outlet I’ve forgotten), or that my internal data model is in a consistent state.</div><div><br class=""></div><div>Both areas of usage have been <i class="">extremely</i> helpful in building my app. They help me identify when I forget to put resources in the right target, or when I make changes to the internal model but forget all the places I’m supposed to insert things. They help me catch when I fat-finger a URL.</div><div><br class=""></div><div>Yes, I could <i class="">absolutely</i> have done all of this with just a bare unwrap operator, but by putting the diagnostic message in there, I get <i class="">immediate</i> feedback as to why my code is failing. I don’t have to go digging around in the code in order to re-teach myself of what invariants are supposed to be held, because the error message gives me the succinct and immediately-actionable thing to do.</div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><b class="">Never and new operator</b></div><div class=""><br class=""></div><div class="">If we introduce the new operator <font face="Menlo" class="">!!</font> solely with the <font face="Menlo" class="">String</font> override, I still have some doubts about it pulling its own weight. Of course, we could add a <font face="Menlo" class="">() -> Never</font> override to increase its usefulness:</div><div class=""><br class=""></div><div class=""><span style="font-family: Menlo;" class="">let user = database.users[userId] !! “User to logout does not exist”</span></div><div class=""><span style="font-family: Menlo;" class="">let user = database.users[userId] !! logFatalError(“User to logout does not exist”)</span></div></div></blockquote><div><br class=""></div><div>As I demonstrate above even just the string version can be extremely helpful.</div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">But Jaden Geller makes a very good point: if and once <font face="Menlo" class="">Never</font> becomes a true bottom type, that syntax will be redundant because <font face="Menlo" class="">Never</font> will be usable with the ?? operator, creating a lot of confusion:</div><div class=""><br class=""></div><div class=""><font face="Menlo" class="">let user = database.users[userId] !! logFatalError(“User to logout does not exist”)<br class="">let user = database.users[userId] ?? logFatalError(“User to logout does not exist”)</font></div></div></blockquote><div><br class=""></div><div>Maybe the answer then is to add !! for strings, and then use ?? If you have a custom Never function.</div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">Those two lines will have exactly the same effect.</div><div class=""><br class=""></div><div class=""><b class="">Cognitive Dissonance of Never and ??</b></div><div class=""><br class=""></div><div class="">Ben Cohen originally mentioned that if we introduce a <font face="Menlo" class="">() -> Never</font> overload of the <font face="Menlo" class="">??</font> operator, there will be cognitive dissonance because the question mark operator is never used in Swift to signal a trap. But if we make <font face="Menlo" class="">Never</font> a true bottom type, which has a lot of advantages, this dissonance will be unavoidable. Shouldn’t we embrace it then?</div><div class=""><font face="Menlo" class=""><br class=""></font></div><div class=""><b class="">Potential for confusion with multiple per line</b></div><div class=""><br class=""></div><div class="">This might not be a real concern, but are we introducing a syntax that will make it possible/encourage people to write less than readable code?</div><div class=""><br class=""></div><div class=""><font face="Menlo" class="">let user = (database !! “Database is not operational”).users[userId !! “User was not set in time”] !! “User to logout does not exist"</font></div></div></blockquote><div><br class=""></div><div>IMO, this is a bit of a red herring, because you can already write similarly atrocious code in Swift today. The addition of “!!” wouldn’t really change that.</div><div><br class=""></div><div>Cheers,</div><div><br class=""></div><div>Dave</div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">David.</div><div class=""><br class=""><div class=""><blockquote type="cite" class=""><div class="">On 28 Jun 2017, at 22:30, Erica Sadun via swift-evolution <<a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><meta http-equiv="Content-Type" content="text/html charset=utf-8" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">Based on the feedback on this thread, I'm coming to the following conclusions:</div><div class=""><br class=""></div><div class="">`!!` sends the <i class="">right semantic message</i>. "Unwrap or die" is an unsafe operation. It is based on `!`, the unsafe forced unwrap operator, and not on `??`, the safe fallback nil-coalescing operator. Its symbology should therefore follow `!` and not `?`. </div><div class=""><br class=""></div><div class="">The `!!` operator should follow the same semantics as `<font face="Menlo" style="font-size: 11px;" class="">Optional.unsafelyUnwrapped</font>`, which establishes a precedent for this approach:</div><div class=""><br class=""></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class="">> "<i class="">The unsafelyUnwrapped property provides the same value as the forced unwrap operator (postfix !). However, in optimized builds (-O), no check is performed to ensure that the current instance actually has a value. Accessing this property in the case of a nil value is a serious programming error and could lead to undefined behavior or a runtime error.</i>"</div></blockquote><div class=""><br class=""></div><div class="">By following `<font face="Menlo" style="font-size: 9px;" class="">Optional.unsafelyUnwrapped</font>`, this approach is consistent with <a href="https://github.com/apple/swift/blob/master/docs/ErrorHandlingRationale.rst#logic-failures" class="">https://github.com/apple/swift/blob/master/docs/ErrorHandlingRationale.rst#logic-failures</a></div><div class=""><br class=""></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class=""><i class=""><span style="font-family: Palatino-Roman;" class="">> "Logic failures are intended to be handled by fixing the code. It means </span><span style="font-family: Palatino-Roman;" class="">checks of logic failures can be removed if the code is tested enough.</span><br style="font-family: Palatino-Roman;" class=""><span style="font-family: Palatino-Roman;" class="">Actually checks of logic failures for various operations, `!`, </span><span style="font-family: Palatino-Roman;" class="">`array[i]`, `&+` and so on, are designed and implemented to be removed</span><br style="font-family: Palatino-Roman;" class=""><span style="font-family: Palatino-Roman;" class="">when we use `-Ounchecked`. It is useful for heavy computation like </span><span style="font-family: Palatino-Roman;" class="">image processing and machine learning in which overhead of those </span><span style="font-family: Palatino-Roman;" class="">checks is not permissible."</span></i></div></blockquote><div class=""><br class=""></div><div class="">The right hand side should use a string (or more properly a string autoclosure) in preference to using a `<font face="Menlo" style="font-size: 11px;" class="">Never</font>` bottom type or a `<font face="Menlo" style="font-size: 11px;" class="">() -> Never</font>` closure. A string provides the cleanest user experience, and allows the greatest degree of self-documentation. </div><div class=""><br class=""></div><div class="">- A string is cleaner and more readable to type. It respects DRY, and avoids using *both* the operator and the call to `fatalError` or `preconditionFailure` to signal an unsafe condition:</div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class=""><span style="font-family: Menlo; font-size: 11px;" class="">`let last = array.last !! “Array guaranteed non-empty" // readable`</span></div></blockquote><div class="">than: </div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class=""><span style="font-family: Menlo; font-size: 11px;" class="">`let last = array.last !! fatalError(“Array </span><span style="font-family: Menlo; font-size: 11px;" class="">guaranteed</span><span style="font-family: Menlo; font-size: 11px;" class=""> non-empty”) // redundant, violates DRY`</span></div><div class=""><br class=""></div></blockquote><div class="">- A string allows the operator *<i class="">itself</i>* to unsafely fail, just as the unary version of `!` does now. It does this with additional feedback to the developer during testing, code reading, and code maintenance. The string provides a self-auditing in-line annotation of the reason why the forced unwrap has been well considered, using a language construct to support this.</div><div class=""><br class=""></div><div class="">- A string disallows a potentially unsafe `Never` call that does not reflect a serious programming error, for example:</div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class=""><span style="font-family: Menlo; font-size: 11px;" class="">let last = array.last !! f() // where </span><span style="font-family: Menlo; font-size: 11px;" class="">func f() -> Never { while true {} }</span></div></blockquote><div class=""><br class=""></div><div class="">- Although as several list members mention, a `Never` closure solution is available today in Swift, so is the `!!` operator solution. Neither one requires a fundamental change to the language.</div><div class=""><br class=""></div><div class="">- Pushing forward on this proposal does not in any way reflect on adopting the still-desirable `Never` bottom type.</div><div class=""><br class=""></div><div class=""><blockquote type="cite" class=""><div class="">On Jun 28, 2017, at 12:42 PM, Tony Allevato via swift-evolution <<a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><div dir="ltr" class=""><br class=""><br class=""><div class="gmail_quote"><div dir="ltr" class="">On Wed, Jun 28, 2017 at 11:15 AM Dave DeLong <<a href="mailto:delong@apple.com" class="">delong@apple.com</a>> wrote:<br class=""></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="word-wrap:break-word" class=""><div class=""><blockquote type="cite" class=""><div class="">On Jun 28, 2017, at 10:44 AM, Adrian Zubarev via swift-evolution <<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a>> wrote:</div><br class="m_-2274859510633634742Apple-interchange-newline"><div class=""><div class="">Well the main debate is that, we all want early access to a feature that will be part of Swift as soon as `Never` becomes the bottom type. When this happens the `??` will automatically support the pitched behavior. Until then if we all agree that we should add it now in a way that will not break anything we can simply add an overload to `??` as I previously showed.<div class=""><br class=""></div></div></div></blockquote><div class=""><br class=""></div></div></div><div style="word-wrap:break-word" class=""><div class=""><div class="">I believe we should add it now, but I like the recent observation that making <font face="Menlo" class=""><span style="font-size:11px" class="">??</span></font> suddenly become a potentially crashing operator violates the expectation that <font face="Menlo" class=""><span style="font-size:11px" class="">?</span></font> is an indication of safety.</div></div></div></blockquote><div class=""><br class=""></div><div class="">?? does *not* become a potentially crashing operator. The *fatalError* (or whatever else the user chooses to put there) on the right-hand side is the crashing operation.</div><div class=""><br class=""></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="word-wrap:break-word" class=""><div class=""><div class=""><br class=""></div><div class="">On the other hand, the existing semantics of Swift are that <font face="Menlo" class=""><span style="font-size:11px" class="">!</span></font> is always dangerous, so making <font face="Menlo" class=""><span style="font-size:11px" class="">!!</span></font> be the a potentially crashing operator is much more consistent with the language.</div></div></div><div style="word-wrap:break-word" class=""><div class=""><br class=""><blockquote type="cite" class=""><div class=""><div class=""><div class="">There is no need for `!!` because it will fade in the future. If you think of `Never` as a bottom type now then `??` will already make total sense. The default value for T from rhs might be T or Never. </div></div></div></blockquote><div class=""><br class=""></div></div></div><div style="word-wrap:break-word" class=""><div class=""><div class="">I respectfully disagree with your absolute position on this topic. Even with <font face="Menlo" class=""><span style="font-size:11px" class="">Never</span></font> as a bottom type in the future, it would <i class="">still</i> be more convenient for me to type:</div><div class=""><br class=""></div><div class=""><font face="Menlo" class=""><span style="font-size:11px" class="">let last = array.last !! “Array must be non-empty"</span></font></div><div class=""><br class=""></div><div class="">… than it ever would be to type:</div><div class=""><br class=""></div><div class=""><font face="Menlo" class=""><span style="font-size:11px" class="">let last = array.last ?? fatalError(“Array must be non-empty”)</span></font></div></div></div><div style="word-wrap:break-word" class=""><div class=""><div class=""><br class=""></div></div></div></blockquote><div class=""><br class=""></div><div class="">There is a very high bar for additions to the standard library—a new operator added to the language is going to be around (1) forever, or (2) indefinitely with some migration cost to users if it's ever removed. Shaving off a few keystrokes doesn't quite meet that bar—especially when an alternative has been shown to work already that provides the same functionality, is more general (not coupled to fatalError or String messages), and that fits better into Swift's design.</div><div class=""><br class=""></div><div class=""><br class=""></div><div class="">To make sure I'm not being too much of a downer, I would completely support this broader feature being implemented by that alternative: the ?? + autoclosure () -> Never combo. Then once Never does become a true bottom type, I believe it could be removed and the calling code would still *just work*.</div><div class=""><br class=""></div><div class=""> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="word-wrap:break-word" class=""><div class=""><div class=""></div><div class="">Dave</div></div></div><div style="word-wrap:break-word" class=""><div class=""><br class=""><blockquote type="cite" class=""><div class=""><div class=""><div class=""><br class=""></div><div class="">@erica: the rhs argument should be called something like `noreturnOrError` and not `defaultValue`. And we should keep in mind that when Never becomes the bottom type we have to remove that overload from stdlib, because otherwise it will be ambiguous. </div><div class=""><br class=""></div><div class="">---</div><div class=""><br class=""></div><div class="">On the other hand if we tackle a different operator then we should rething the 'default value operator' because the second ? signals an optional but not a non-optional or an inplicit unwrapped operator. In that case I personally thing ?! would make more sense. Unwrap or (non-optional | IUO | trap/die)<br class=""> <br class=""><div class="m_-2274859510633634742bloop_sign"><div style="font-family:helvetica,arial;font-size:13px" class="">-- <br class="">Adrian Zubarev<br class="">Sent with Airmail</div></div><p class="gmail_quote">Am 28. Juni 2017 um 18:13:18, Tony Allevato via swift-evolution (<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a>) schrieb:</p> <blockquote type="cite" class="gmail_quote"><span class=""><div class=""><div class=""></div><div class="">
<div class="">
<div class="">It's hard for me to articulate, but "foo !! message" feels a
little too much like a Perl-ism for my taste. Objectively that's
not a great criticism on its own, but I just don't like the "smell"
of an operator that takes a value on one side and a string for
error reporting purposes on the other. It doesn't feel like it fits
the style of Swift. I prefer a version that makes the call to
fatalError (and thus, any other non-returning handler) explicitly
written out in code.<br class="">
<br class="">
So, if the language can already support this with ?? and
autoclosure/Never as was shown above, I'd rather see that added to
the language instead of a new operator that does the same thing
(and is actually less general).</div>
</div>
<div class="">
<div class=""><br class="">
<div class="gmail_quote">
<div class="">On Wed, Jun 28, 2017 at 8:52 AM Jacob Williams via
swift-evolution <<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a>>
wrote:<br class=""></div>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
<div style="word-wrap:break-word" class="">
<div class="">I feel that the !! operator would be necessary for indicating
that if this fails then something went horribly wrong somewhere and
we should throw the fatalError. This allows the inclusion of
optimizations using -Ounchecked and is clear that this is an
operation that could result in a runtime error just like force
unwrapping.</div>
<div class=""><br class=""></div>
<div class="">If we want code clarity and uniformity, then I think !! Is
much better than ?? because it goes right along with the single !
Used for force unwrapping. However, this does depend on if the
operator would be returning some kind of error that would cause the
program to exit.</div>
<div class=""><br class=""></div>
<div class="">I think the ?? operator should not cause a program to exit
early. It goes against optional unwrapping principles. I think code
could get very confusing if some ? would return nil/a default
value, and others would be causing your program to crash and exit.
The ? operators should always be classified as safe
operations.</div>
</div>
<div style="word-wrap:break-word" class="">
<div class=""><br class="">
<div class="">
<blockquote type="cite" class="">
<div class="">On Jun 28, 2017, at 9:41 AM, Ben Cohen via swift-evolution
<<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a>> wrote:</div>
<br class="m_-2274859510633634742m_2866777249939610229m_1922728200947037084Apple-interchange-newline">
<div class="">
<div style="word-wrap:break-word" class=""><br class="">
<div class="">
<blockquote type="cite" class="">
<div class="">On Jun 28, 2017, at 8:27 AM, David Hart via swift-evolution
<<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a>> wrote:</div>
<br class="m_-2274859510633634742m_2866777249939610229m_1922728200947037084Apple-interchange-newline">
<div class=""><span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant-caps:normal;font-weight:normal;letter-spacing:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important" class="">
Count me in as a strong proponent of ?? () -> Never. We don't
need to burden the language with an extra operator just for
that.</span><br class="m_-2274859510633634742m_2866777249939610229m_1922728200947037084Apple-interchange-newline">
</div>
</blockquote>
</div>
<br class="">
<div class="">You could say the same about ??</div>
<div class=""><br class=""></div>
<div class="">The concern that an additional operator (and one that, IMO,
fits well into existing patterns) is so burdensome seems way
overweighted in this discussion IMO. </div>
<div class=""><br class=""></div>
<div class="">Adding the operator, and encouraging its use, will help foster
better understanding of optionals and legitimate use of
force-unwrapping in a way that I don’t think `?? fatalError`
could.</div>
<div class=""><br class=""></div>
<div class=""><br class=""></div>
</div>
_______________________________________________<br class="">
swift-evolution mailing list<br class="">
<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a><br class="">
<a href="https://lists.swift.org/mailman/listinfo/swift-evolution" target="_blank" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class="">
</div>
</blockquote>
</div>
<br class=""></div>
</div>
_______________________________________________<br class="">
swift-evolution mailing list<br class="">
<a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a><br class="">
<a href="https://lists.swift.org/mailman/listinfo/swift-evolution" rel="noreferrer" target="_blank" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class="">
</blockquote>
</div>
</div>
</div>
_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a><br class=""><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" target="_blank" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class=""></div></div></span></blockquote>
</div></div>_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" target="_blank" class="">swift-evolution@swift.org</a><br class=""><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" target="_blank" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class=""></div></blockquote></div></div></blockquote></div></div>
_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a><br class=""><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class=""></div></blockquote></div><br class=""></div>_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a><br class=""><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class=""></div></blockquote></div><br class=""></div></div>_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a><br class="">https://lists.swift.org/mailman/listinfo/swift-evolution<br class=""></blockquote></div><br class=""></body></html>