Hello, I’m fairly new to Rust and came across this. Can someone explain to me how the following example is able to infer the constant value from the array length passed in? At this point, inferred type generation for function calls are a bit hand wavy, to me, does anyone know of a resource that breaks down all the different ways they can be used (for instance in this example I hadn’t seen them used for consts) and what their limitations are in Rust? I often run across a ‘this type can not be inferred’ error without really knowing why not and just throw in the type to make it go away.
Any other examples people could point me to would be appreciated as well.
Thanks!
#[derive(Debug)]
struct Buffer<T, const LENGTH: usize> {
buf: [T; LENGTH],
}
impl<T, const LENGTH: usize> From<[T; LENGTH]> for Buffer<T, LENGTH> {
fn from(buf: [T; LENGTH]) -> Self {
Buffer { buf }
}
}
fn main() {
let buf = Buffer::from([0, 1, 2, 3,5]);
dbg!(&buf);
}
It works because the size of an array in main() function is known at compile time. Arrays in Rust have fixed size, at that size is part of their type. The type of the array you pass to from() is
[]Since deadcream already told you the reason. I’m gonna explain a more generic way.
There are 2 important times: compilation time and run time.
At compilation time, everything that is constant, is known to the compiler, or can be calculated by it.
At run time, everything* is known.
Types have to be generated at compilation time**. This means that generics have to be also known at compilation time.
In this case. Both the “T” type of the buffer and its size “LENGTH” are generic, so they must be known at compile time. Compile time usually doesn’t know about vales of variables, except if those variables are “const”. Then it is known. A value literal is the same as a const variable.
So here, you provide a value literal ([0,1,2,3,4]) which is a fixed array, that is, both its “T” type (i32 by default) and length (5) are known at compile time. Buffer has all the information it needs to become a real type instead of a generic one. In this case, the type will be Buffer<i32, 5>
* Things that are optimized out at compile time are not known at runtime, but yes at compile time. For example:
const A: i32 = 5; const B: i32 = 5+1; fn main() { dbg!(B) }Since A is never used (except to calculate B, which is const), A is probably optimized out. However, since B is used, there probably is a 6 somewhere in memory. Notice how I say probably since optimizations are optional. Or more optimizations may even remove the 6, and convert it to an ASCII “6” to be printed out.
**While this is always true trait objects (like Box<dyn ToString>) can act like some kind of runtime type, if you need that functionality.
I recommend using numbered footnotes (
¹,²etc.) or escaping the asterisk (\*) instead of using plain asterisks for footnotes, because the asterisk is also used in Markdown for emphasis and list items.
