A type for functions that never return

[manveru]

It might be a good idea to have a type for functions/expressions/keywords that never return? So one could write:

pub fn wait_for_the_heatdeath_of_the_universe() -> NeverReturn {
  process.sleep_forever()
}

This would have to be supported at the language level to be truly helpful, by warning about code coming after it, since it won't ever execute it.

[lpil]

I'd be open to this addition! I believe we once had an issue for it.

We need to work out the exact semantics, it'll be different from any type we have so far.

[lpil]

Elm's Never doesn't have any of the functionality we're after here, it's just an unconstructable custom type. Rust is a good one to reference

[timjs]

Could you explain why Elm's Never doesn't have the functionality you're after and Rust's has? When you have an unconstructable custom type, you can use it to signal functions never return, because they can never create a value of such a type.

Both Elm's Never and Rust's ! are incarnations of the same thing and used in the same way, similar to Swift's Never. They're called the empty type or void type in type theory. Note that void here is not the same as the unit type which is spelled Nil in Gleam.

I called it a "natural idea to add" because of how custom types in Gleam currently work. When defining Nil, one writes:

type Nil {
  Nil
}

The beauty of having a functional language like Gleam, and having algebraic data types, is that, to define a Never type, the only thing to do is write:

type Never {}

This is already possible. So we'd only need to add this to the Gleam std-lib and promote it's use cases.

See this blog post about Haskell for more background info, and take a look at Wikipedia's the type theory page, especially the section on empty type.

---

PS Although one could make a multitude of unit types in Gleam using custom types with a single constructor, when experimenting for this post, I noticed that Gleam has actually two built in unit types: Nil and the empty tuple #(). Not a very big problem, but quite some languages make these aliases: Swift's Void (Bad naming! Should be called Unit!), Haskell, Elm, OCaml, etc. Other solution would be to remove #().

[inoas]

if this is possible

type Never {}

can't we simply add that to the prelude in the compiler, the tour and be done with it?

[lpil]

@timjs because the compiler doesn't emit warnings for code after it, which is what the Gleam proposal is for adding. We already have anything the Elm never type has.

[timjs]

Ahh, that would indeed be a good service from the compiler to add!

[Pi-Cla]

I am cooking up the Never type rn

[inoas]

https://hexdocs.pm/funtil/funtil.html#Never not good enough?

[Pi-Cla]

I guess the point of adding it to the Prelude is to allow the compiler to issue a warning of any expressions after a function of type Never. Could this be done in a package?

[inoas]

That would be awesome.

Could a similar warning happen for expressions after panic (same wrapping block only) or todo (same wrapping block only)