RustBrock/data_types.md

Data Types

Constants

constants can be delared anywhere, convension to use all caps in const need const keyword, not always eval at compile time variables can only be assigned once (needs mut to assign more than once (need to be same type))

const SECONDS_PER_HOUR: i32 = 60 * 60;

Variables

variables are immuatable by default variables can be inferred but sometimes needs explicit typing

    let foo = 5;

need to add mut keyword to enable rewriting, generally avoid unless actually used

    let mut bar = 6;

SHADOWING

Cannot have mutable shadows

allows for reuse of namespace instead of spaces_str and spaces_num

    let spaces = " _ _ ";
    let spaces = spaces.len();
    // will output 5 instead of " _ _ " beacuse that is how long it is
    // the shadow of spaces (first) wont be printed until the overshadow of spaces goes out of scope
    println!("{spaces}"); // output: 5

not allowed shadow

    let mut spaces = " _ _ ";
    spaces = spaces.len();

cannot change type of variable once declared

Primitive Data Types

Scalars

Integers

u is for usigned integers i is for signed integers

number indicated how many bits it takes in memory

    let z: i8;      // takes up 8 bits, can store values from -128 to 127
    let c: i16;     // takes up 16 bits
    let d: i32;     // takes up 32 bits (default for integers)
    let e: i64;     // takes up 64 bits
    let f: i128;    // takes up 128 bits
    let g: isize;   // takes up x bits, depends on the system's architecture/cpu

    let h: u8;      // takes up 8 bits, unsigned version (only positive)
                    // can store values from 0 to 255

Integer Overflow

will reset to the lowest value ie i8 129 -> -126

    let example_over_flow: i8 = 129;

behavor only in production mode dev mode will cause a panic and error out/tell you

Floats

better to use double point due to modern cpus where there is not much difference in speed

Single Point Float

takes up 32 bits

    let a: f32 = 4.0;

Double Point Float

takes up 64 bits

    let b: f64 = 2.01;

Integers Represented Differently

can represent values in hex, oct, bin or dec can hover with rust-analyzer extension to see value in dec

Dec with Reading Aid

value stored 1000 _ used to make easier to read

    let i = 1_000;

Hexidecimal

value stored 255

    let j = 0xff;

Octal

value stored 63

    let k = 0o77; 

Binary

value stored 13

    let l = 0b1101;

Numeric Operators / Basic Math

Numbers for reference

    let x: i16 = 8;
    let y: i16 = 5;

Addition

    let sum  = x + y; // result: 13

Subtraction

    let difference = x - y; //result: 3

Multiplication

    let product: i16;
    product = x * y;

Division

    let quotent = 45.1 / 54.2;
    let truncated = x / y; // results in 1 (always rounds down)

Remainder

    let remainder = x % y;

Booleans

must be explicity typed to true or false 0 or 1 not allowed even with let var: bool

    let m = false;
    let n = true;

Char

must use single quotes and not "" otherwise will be inferred as string literal is stored as Unicode Scalar Value allowing for emoji, japanse char and other languages not supported by ASCII takes 4 bytes in size or 32 bits

    let o = 'a';

Compound Types