News for hackers. Stuff that matters.
Re:Bottom Type in F# by slaymaker1907 on Wednesday September 23, 2020 @04:12AM (#24564344)
Rust actually has a type like this in addition to a bottom type (which is !). It is the Infallible type which is an enum type (a sum type) with no variants and is thus not constructible. It's purpose is to indicate that an operation always succeeds when that operation returns a Result type. But defining it that way, the compiler can use this information to remove error checks. While it doesn't implement every trait automatically, I found it to be pretty easy to implement every trait I cared about since the it just had to typecheck and not do anything useful.
Re:Bottom Type in F# by Sharlin on Wednesday September 23, 2020 @06:17AM (#24565209)
`Infallible` only exists because an arbitrary empty type was needed to signal a `Result` that's always `Ok` and the "official" never type `!` was not yet implemented/stable. If it weren't for backward compatibility, `Infallible` could be removed from the standard library right now and its uses replaced with `!`.

However, `!` is not a real bottom type either, not yet anyway, because it is not the subtype of every type. As of now it is an unsolved problem how exactly one would go about making it one.

Re:Bottom Type in F# by EE84M3i on Wednesday September 23, 2020 @09:26AM (#24566770)
I'm not too familiar with rust's syntax -- isn't `!` normally used after identifiers to indicate macro invocation? Or is it part of the identifier that happens to name a macro?

More accurately, when I have a function that returns `!`, is that `!` a special syntax construct at the parser level, a keyword, or a name from the prelude? Or is there some special zero-name macro that is invoked? Can I put a bang in my own type name?

https://doc.rust-lang.org/reference/types/never.html seems to answer the question "it's special"

I guess the docs are: https://doc.rust-lang.org/std/primitive.never.html

Re:Bottom Type in F# by DougBTX on Wednesday September 23, 2020 @09:33AM (#24566844)
> isn't `!` normally used after identifiers to indicate macro invocation?

I'm not sure where that's explicitly documented, but the docs for procedural macros call it the "macro invocation operator":

https://doc.rust-lang.org/reference/procedural-macros.html#f...

> Also, I tried searching but I couldn't find an entry for `!` in the docs.

Yeah, that's one reason I'd prefer that it had an explicit name, rather than a single character.

Re:Bottom Type in F# by nicoburns on Wednesday September 23, 2020 @10:18AM (#24567347)
A special syntax construct at the parser level I think. In fact currently the `-> !` syntax for functions is it's own special syntax distinct (although v. similar in meaning) from the `!` type.

It's not a macro (macro invocations just use the same character), and you can't have a '!' in your own type names.

Re:Bottom Type in F# by Sharlin on Wednesday September 23, 2020 @11:34AM (#24568252)
Yeah, in current stable Rust `-> !` is just a syntactic construct. But it is being reified into a proper first-class type [1], indeed in nightly you've been able to use it in most type positions for a while already (I actually forgot that the "basic" implementation is not yet stable!)

[1] https://github.com/rust-lang/rust/issues/35121

Re:Bottom Type in F# by vmchale on Wednesday September 23, 2020 @08:49AM (#24566354)
That's a void type, not a bottom type.