<div dir="ltr"><div><div style="font-size:12.8px">> If you mean does this currently compile:</div><div style="font-size:12.8px"><br></div><div style="font-size:12.8px"><div style="margin:0px;font-size:11px;line-height:normal;font-family:menlo"><span style="font-variant-ligatures:no-common-ligatures">let f:Optional<Never> = nil</span></div><div style="margin:0px;font-size:11px;line-height:normal;font-family:menlo"><span style="font-variant-ligatures:no-common-ligatures">let g:[Never] = []</span></div></div></div><div><span style="font-size:12.8px"><br></span></div><div><span style="font-size:12.8px">Of course it compiles, but it does not if you remove the type annotations. My point was that, with a bit of work, you could remove those annotations and still typecheck</span></div><div><span style="font-size:12.8px"><br></span></div><span style="font-size:12.8px">> If Never becomes a bottom type, a [Never] or Never? hypothetically could be passed into any function which accepts an array or optional of any type because of covariance and value types, but would always be empty/none version of that type. I can’t think of a practical reason to do this</span><br><div><span style="font-size:12.8px">It could be useful to mitigate</span> the absence of GADT in this simple case:<br></div><div>
<p class="gmail-p1"><span class="gmail-s1">let</span><span class="gmail-s2"> value: </span><span class="gmail-s3">Either</span><span class="gmail-s2"><</span><span class="gmail-s4">Int</span><span class="gmail-s2">, </span><span class="gmail-s4">String</span><span class="gmail-s2">> = .</span><span class="gmail-s3">left</span><span class="gmail-s2">(</span><span class="gmail-s5">3</span><span class="gmail-s2">) // TypeChecks</span><br></p><p class="gmail-p1"><span class="gmail-s2"><span class="gmail-s1">let</span><span class="gmail-s2"> value: </span><span class="gmail-s3">Either</span><span class="gmail-s2"><</span><span class="gmail-s4">Int</span><span class="gmail-s2">, Never</span><span class="gmail-s2">> = .</span><span class="gmail-s3">left</span><span class="gmail-s2">(</span><span class="gmail-s5">3</span><span class="gmail-s2">) // TypeChecks</span><br></span></p><p class="gmail-p1"><span class="gmail-s2"><span class="gmail-s2"><span class="gmail-s1">let</span><span class="gmail-s2"> value</span><span class="gmail-s2"> = .</span><span class="gmail-s3">left</span><span class="gmail-s2">(</span><span class="gmail-s5">3</span><span class="gmail-s2">) // Does not typecheck</span></span></span></p><p class="gmail-p1">The third line could be inferred as the second. And using the property you are mentioning (passing values with Never types parameters to functions with covariant argument) you could very simply do</p><p class="gmail-p1">func takeEither(e: Either<Int, String>) { … }<br></p><p class="gmail-p1">takeEither(.left(3))</p></div></div><div class="gmail_extra"><br><div class="gmail_quote">2017-05-15 8:44 GMT+02:00 David Waite <span dir="ltr"><<a href="mailto:david@alkaline-solutions.com" target="_blank">david@alkaline-solutions.com</a>></span>:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="word-wrap:break-word"><br><div><span class=""><blockquote type="cite"><div>On May 14, 2017, at 11:44 PM, André Videla via swift-evolution <<a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a>> wrote:</div><br class="m_-5927955668063646054Apple-interchange-newline"><div><div><blockquote type="cite">Joe also referred to the following model in a thread about Typed Throws.<br><br> () -> () == () throws Never -> ()<br> () throws -> () == () throws Error -> ()<br></blockquote>That makes sense! As a bottom type it would be perfectly fit for this.<br><br><blockquote type="cite">On 15 May 2017, at 03:01, Robert Widmann <<a href="mailto:devteam.codafi@gmail.com" target="_blank">devteam.codafi@gmail.com</a>> wrote:<br><br>Though our type lattice doesn’t necessarily have a bottom in the way you’re looking for, you can use Never-returning functions to inhabit a combinator that will do this for you.<br></blockquote>Very useful.<br>What do you think of [] as [Never], or nil as Optional<Never>. Can the current inference and subtyping rules deal with that? <br></div></div></blockquote><div><br></div></span><div>If you mean does this currently compile:</div><div><br></div><div><div style="margin:0px;font-size:11px;line-height:normal;font-family:Menlo;background-color:rgb(255,255,255)"><span style="font-variant-ligatures:no-common-ligatures">let f:Optional<Never> = nil</span></div><div style="margin:0px;font-size:11px;line-height:normal;font-family:Menlo;background-color:rgb(255,255,255)"><span style="font-variant-ligatures:no-common-ligatures">let g:[Never] = []</span></div><div style="margin:0px;font-size:11px;line-height:normal;font-family:Menlo;background-color:rgb(255,255,255)"><br></div></div>then yes. However, “nil” and “[]” in the above are literals, not types or type instances. They only are used to initialize an instance of a type that is ExpressibleByNilLiteral / ExpressibleByArrayLiteral.</div><div><br></div><div>If Never becomes a bottom type, a [Never] or Never? hypothetically could be passed into any function which accepts an array or optional of any type because of covariance and value types, but would always be empty/none version of that type. I can’t think of a practical reason to do this, although I admit I’ve never used a language with a bottom type.</div><span class="HOEnZb"><font color="#888888"><div><br></div><div>-DW</div></font></span></div></blockquote></div><br></div>