>fn main() {
>// Suffixed literals, their types are known at initialization
>let x = 1u8;
>let y = 2u32;
>let z = 3f32;
>// Unsuffixed literals, their types depend on how they are used
>let i = 1;
>let f = 1.0;
>// `size_of_val` returns the size of a variable in bytes
>println!("size of `x` in bytes: {}", std::mem::size_of_val(&x));
>println!("size of `y` in bytes: {}", std::mem::size_of_val(&y));
>println!("size of `z` in bytes: {}", std::mem::size_of_val(&z));
>println!("size of `i` in bytes: {}", std::mem::size_of_val(&i));
>println!("size of `f` in bytes: {}", std::mem::size_of_val(&f));
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
There are some concepts used in the previous code that haven't been explained yet, here's a brief explanation for the impatient readers:
• std::mem::size_of_val is a function, but called with its full path. Code can be split in logical units called modules. In this case, the size_of_val function is defined in the mem module, and the mem module is defined in the std crate. For more details, see modules and crates.
The type inference engine is pretty smart. It does more than looking at the type of the value expression during an initialization. It also looks at how the variable is used afterwards to infer its type. Here's an advanced example of type inference:
>fn main() {
>// Because of the annotation, the compiler knows that `elem` has type u8.
>let elem = 5u8;
>// Create an empty vector (a growable array).
>let mut vec = Vec::new();
>// At this point the compiler doesn't know the exact type of `vec`, it
>// just knows that it's a vector of something (`Vec<_>`).
>// Insert `elem` in the vector.
>vec.push(elem);
>// Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec`)
>// TODO ^ Try commenting out the `vec.push(elem)` line
>println!("{:?}", vec);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
