# 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))

```rust
const SECONDS_PER_HOUR: i32 = 60 * 60;
```

## Variables

variables are immuatable by default
variables can be inferred but sometimes needs explicit typing
    
```rust
    let foo = 5;
```
need to add mut keyword to enable rewriting, generally avoid unless actually used

```rust
    let mut bar = 6;
```

# SHADOWING

#### Cannot have mutable shadows

allows for reuse of namespace instead of spaces_str and spaces_num
```rust
    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
```rust
    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
```rust    
    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
```rust 
    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
```rust
    let a: f32 = 4.0;
```

#### Double Point Float
takes up 64 bits
```rust
    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
```rust
    let i = 1_000;
```

##### Hexidecimal
value stored 255
```rust
    let j = 0xff;
```

##### Octal
value stored 63
```rust
    let k = 0o77; 
```

##### Binary
value stored 13
```rust
    let l = 0b1101;
```

## Numeric Operators / Basic Math
Numbers for reference
```rust
    let x: i16 = 8;
    let y: i16 = 5;
```

### Addition
```rust
    let sum  = x + y; // result: 13
```

### Subtraction
```rust
    let difference = x - y; //result: 3
```

### Multiplication
```rust
    let product: i16;
    product = x * y;
```

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

### Remainder
```rust
    let remainder = x % y;
```

### Booleans
must be explicity typed to true or false
0 or 1 not allowed even with let var: bool
```rust
    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
```rust
    let o = 'a';
```

### Compound Types