# Basic Types

## Literals

 integer `1` `2` `3` float `1.2` `2.3` `4.5` character `'a'` `'b'` `'c'` string `"abcdefg"` boolean `true` `false` symbol `:abc` `:defg` `:hi`

## Primitives

 integer `i1` `i2` `i4` `i8` `i16` `i32` `i64` `i128` `i256` … unsigned `u1` `u2` `u4` `u8` `u16` `u32` `u64` `u128` `u256` … float `f32` `f64` char `char` boolean `bool` symbol `symbol`

## Compounds

### Arrays

``````// All of these make the same array
let array = [1, 2, 3]
let array = [i32; 3] { it }
let array = [
, 1
, 2
, 3
]
``````
``````              ┌──────────── array type
│   ┌──────── array length
│   │    ┌─── iterator index
let array = [i32; 3] { it }
``````

An inner array

``````let mut outer: i32[] = [1, 2, 3, 4, 5]
let mut inner: i32[] = outer[1; 3]

// outer : 1, 2, 3, 4, 5
// inner :    2, 3, 4

outer = 8;

// outer : 1, 2, 8, 4, 5
// inner :    2, 8, 4

``````
``````      ┌───── starting position
│  ┌── length of inner array
outer[1; 3];
``````

### Multidimensional Arrays

Multidimensional arrays are stored in contiguous memory as a single array, but are accessed with multiple values.

#### 2D

``````let mut array: i32[,] = [i32; 4, 4] { it_x * it_y }

// array:
// 0 0 0 0
// 0 1 2 3
// 0 2 4 6
// 0 3 6 9

// Modify the array
array[2, 3] = 6
``````

#### 3D

``````let mut [i32,,] array = [i32; 4, 4, 4] => it_x * it_y * it_z

// Modify the array
array[2, 3, 1] = 4
``````

You can have as many dimensions as you like, but remember that each dimension consumes exponentially more memory.

``````let [Type] array_1d     = [i32; x] { value }             array_1d[x]
let [Type,] array_2d    = [i32; x, y] { value }          array_2d[x, y]
let [Type,,] array_3d   = [i32; x, y, z] { value }       array_3d[x, y, z]
let [Type,,,] array_4d  = [i32; x, y, z, w] { value }    array_4d[x, y, z, w]
let [Type,,,,] array_5d = [i32; x, y, z, w, h] { value } array_5d[x, y, z, w, h]
...
``````

### Jagged Arrays

Jagged arrays are arrays of arrays and are not stored in contiguous memory. These are slower, and have less memory efficiency than a multidimensional array, but have the advantage of being able to change an entire row in one instruction.

``````let mut array = [i32[]; 4] (it_outer) { [i32; 4] { it_outer * it } }
let row = [i32; 4] { it + 2 }
array = row
array = 6
``````

### Tuples

``````fn GetTuple(tuple: (i32, string)): (i32, string) {
let (num, str) = tuple
return (num + 1, str + " pizzas")
}

let tuple = (15, "Krusty Krab")
let new_tuple = GetTuple(tuple)
let (num, str) = new_tuple
Console::Print("I have \${num} \${str}")
``````

TODO.