Rust by Example

// 300.0 is 255

println!("300.0 is {}", 300.0_f32 as u8);

// -100.0 as u8 is 0

println!("-100.0 as u8 is {}", -100.0_f32 as u8);

// nan as u8 is 0

println!("nan as u8 is {}", f32::NAN as u8);

// This behavior incures a small runtime cost and can be avoided with unsafe methods, however the results might overflow and return **unsound values**. Use these methods wisely:

unsafe {

// 300.0 is 44

println!("300.0 is {}", 300.0_f32.to_int_unchecked::());

// -100.0 as u8 is 156

println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::());

// nan as u8 is 0

println!("nan as u8 is {}", f32::NAN.to_int_unchecked::());

}

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Literals

Numeric literals can be type annotated by adding the type as a suffix. As an example, to specify that the literal 42 should have the type i32, write 42i32.

The type of unsuffixed numeric literals will depend on how they are used. If no constraint exists, the compiler will use i32 for integers, and f64 for floating-point numbers.

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: