Why would I use divergent functions?

by

It has several uses. It can be used for functions which are designed to panic or exit the program. panic!() itself is one such function, but it can also be applied to functions which wrap panic!(), such as printing out more detailed error information and then panicking.

It can also be used for functions that never return. If a function goes into an infinite loop, such as the main loop of a server, and thus never returns, it could be defined this way.

Another possible use would be a wrapper around the Unix exec family of functions, in which the current process is replaced with the one being executed.

It is useful to have such a type because it is compatible with all other types. In order to be type safe, Rust has to ensure that all branches of a match or if statement return the same type. But if there are some branches that are unreachable or indicate an error, you need some way to throw an error that will unify with the type returned by the other branches. Because ! unifies with all types, it can be used in any such case.

There is an interesting RFC (and discussion) at the moment that argues (in part) for expanding the places where ! can be used, arguing that it should be treated as a full fledged type like () is; ! being a type with no values that unifies with all other types, while () being a distinct type with a single value. I’m not sure I agree with the full RFC, but the discussion of treating ! as a full-fledged type is interesting and I think could be proposed separately from the rest of the RFC.

Update: Since I wrote the above, the part of the RFC about promoting ! to a full fledged type was split into a separate RFC and merged, and is in the process of being implemented (currently available in nightly builds behind a feature gate). As a full-fledged type, it can be used in more contexts, such as in Result<T, !> indicating a result that can never fail, or Result<!, E> as one that can never succeed. These are useful in generic contexts; if you have some trait that requires a method to return a result, but for that particular implementation it can only possibly succeed, you don’t need to fill in some dummy error type.

More Related Contents:

  1. How do I create a heterogeneous collection of objects?
  2. Is it possible to control the size of an array using the type parameter of a generic?
  3. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  4. Are polymorphic variables allowed?
  5. Does println! borrow or own the variable?
  6. Efficiently mutate a vector while also iterating over the same vector
  7. Why is it possible to implement Read on an immutable reference to File?
  8. Compare enums only by variant, not value
  9. Why do I need rebinding/shadowing when I can have mutable variable binding?
  10. How can I put an async function into a map in Rust?
  11. How to operate on 2 mutable slices of a Rust array?
  12. Mutating one field while iterating over another immutable field
  13. Why does Rust allow mutation through a reference field using an immutable binding?
  14. Multiple return types from a method
  15. How to end a borrow in a match or if let expression?
  16. How do I synchronously return a value calculated in an asynchronous Future?
  17. Why does this mutable borrow live beyond its scope?
  18. Why does creating a mutable reference to a dereferenced mutable reference work?
  19. Cannot borrow `x` as mutable more than once at a time
  20. Removing elements from a Vec based on some condition [duplicate]
  21. How can I change enum variant while moving the field to the new variant?
  22. Why does Rust disallow mutable aliasing?
  23. How to store rusqlite Connection and Statement objects in the same struct in Rust? [duplicate]
  24. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  25. print! macro not executed until pressing Enter
  26. How can I override a constant via a compiler option?
  27. Why am I getting “parameter is never used [E0392]”?
  28. Use of undeclared type or module `std` when used in a separate module
  29. Is there an elegant solution to modifying a structure while iterating?
  30. How do I cope with lazy iterators?

Leave a Comment