What is the difference between immutable and const variables in Rust?

by

const, in Rust, is short for constant and is related to compile-time evaluation. It shows up:

  • when declaring constants: const FOO: usize = 3;
  • when declaring compile-time evaluable functions: const fn foo() -> &'static str

These kinds of values can be used as generic parameters: [u8; FOO]. For now this is limited to array size, but there is talk, plans, and hope to extend it further in the future.

By contrast, a let binding is about a run-time computed value.

Note that despite mut being used because the concept of mutability is well-known, Rust actually lies here. &T and &mut T are about aliasing, not mutability:

  • &T: shared reference
  • &mut T: unique reference

Most notably, some types feature interior mutability and can be mutated via &T (shared references): Cell, RefCell, Mutex, etc.

Note: there is an alternative use of mut and const with raw pointers (*mut T and *const T) which is not discussed here.

More Related Contents:

  1. Why is it possible to implement Read on an immutable reference to File?
  2. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  3. Why do I need to import a trait to use the methods it defines for a type?
  4. Why does linking lifetimes matter only with mutable references?
  5. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  6. Should trait bounds be duplicated in struct and impl?
  7. Can I do type introspection with trait objects and then downcast it?
  8. How can I perform parallel asynchronous HTTP GET requests with reqwest?
  9. Convert a String to int?
  10. How do I borrow a RefCell, find a key, and return a reference to the result? [duplicate]
  11. Is there a way other than traits to add methods to a type I don’t own?
  12. What is the difference between `e1` and `&e2` when used as the for-loop variable?
  13. What does ‘let x = x’ do in Rust?
  14. Is it possible to return either a borrowed or owned type in Rust?
  15. Example of how to use Conditional Compilation Macros in Rust
  16. How can I call a raw address from Rust?
  17. Is there a way to perform an index access to an instance of a struct?
  18. How to use a local unpublished crate?
  19. Why do I get “type annotations needed” when using Iterator::collect?
  20. Why would I use divergent functions?
  21. How to generate statically linked executables?
  22. Why can I iterate over a slice twice, but not a vector?
  23. What is the difference between `|_| async move {}` and `async move |_| {}`
  24. Cannot use moved BufReader after for loop with bufreader.lines()
  25. Expected closure, found a different closure
  26. How can I iterate on an Option?
  27. How does the Rust compiler know `Cell` has internal mutability?
  28. Creating Diesel.rs queries with a dynamic number of .and()’s
  29. How do I match based on a dynamic variable?
  30. How to match trait implementors

Leave a Comment