Basic types in Rust

use std::mem;

// i8 u8 i16 u16 i32 u32 i64 u64
// isize usize - platform specific (32bit/64bit)
// char
// f32 f64
// true false

fn main() {
    //immutable by default
    let a: u8 = 255;
    //unsigned integer 8bits = 1byte - from 0 to +255 (256 states)
    println!("a = {}, size: {} bytes", a, mem::size_of_val(&a));

    //mut - mutable
    let mut b: i8 = 127;
    //signed integer 8bits = 1byte - from -128 to +127 (256 states)
    println!("b = {}, size: {} bytes", b, mem::size_of_val(&b));
    b = -5; //modify variable b
    println!("new value of variable \"b\" is {}", b);

    //inferred type is i32 by default
    let c = 2_147_483_647;
    //signed integer 32bits = 4bytes - from -2,147,483,648 to +2,147,483,647
    //(4,294,967,295 states)
    println!("c = {}, size: {} bytes", c, mem::size_of_val(&c));

    let d: i16 = 32_767;
    //signed integer 16bits = 2bytes - from -32,768 to +32,767
    //(65,535 states)
    println!("d = {}, size: {} bytes", d, mem::size_of_val(&d));

    let e: isize = 123;
    //platform specific (win64) signed integer 64bits = 8bytes
    println!("e = {}, take up {} bytes on WIN {}-bit", e, mem::size_of_val(&e),
             mem::size_of_val(&e) * 8);

    let f: char = 'a'; // UTF-32 (32bits = 4bytes)
    println!("f = '{}', size: {} bytes", f, mem::size_of_val(&f));

    let g = 5.5;
    //signed double 64bits = 8bytes - inferred by default
    println!("g = {}, size: {} bytes", g, mem::size_of_val(&g));

    let h: f32 = 6.6;
    //signed float 32bits = 4bytes
    println!("h = {}, size: {} bytes", h, mem::size_of_val(&h));

    let i = true;
    //boolean 8bits = 1byte
    println!("i = {}, size: {} bytes", i, mem::size_of_val(&i));
}

//Type Explicit Conversions and Suffixes:
let _a: i16 = -150;
let _b = -150 as i16;
let _c = -1500i16;
let _c = -1500_i16;