Compile-time constants and deterministic functions.
Sometimes a certain value is used many times throughout a program, and it can become
inconvenient to copy it over and over. What's more, it's not always possible or desirable to
make it a variable that gets carried around to each function that needs it. In these cases, the
const keyword provides a convenient alternative to code duplication.
const THING: u32 = 0xABAD1DEA; let foo = 123 + THING;Run
Constants must be explicitly typed, unlike with
let you can't ignore its type and let the
compiler figure it out. Any constant value can be defined in a const, which in practice happens
to be most things that would be reasonable to have a constant (barring
const fns). For
example, you can't have a File as a
The only lifetime allowed in a constant is
'static, which is the lifetime that encompasses
all others in a Rust program. For example, if you wanted to define a constant string, it would
look like this:
const WORDS: &str = "hello rust!";Run
Thanks to static lifetime elision, you usually don't have to explicitly use 'static:
const WORDS: &str = "hello convenience!";Run
const items looks remarkably similar to
static items, which introduces some confusion as
to which one should be used at which times. To put it simply, constants are inlined wherever
they're used, making using them identical to simply replacing the name of the const with its
value. Static variables on the other hand point to a single location in memory, which all
accesses share. This means that, unlike with constants, they can't have destructors, and act as
a single value across the entire codebase.
Constants, as with statics, should always be in SCREAMING_SNAKE_CASE.
const keyword is also used in raw pointers in combination with
mut, as seen in
*const T and
*mut T. More about that can be read at the pointer primitive part of the Rust docs.