Remove unneeded semicolon from examples/demo and examples/all

2 files changed, 810 insertions, 798 deletions

diff --git a/examples/all/all_main.odin b/examples/all/all_main.odin
index e04cf7d49..e67da4648 100644
--- a/examples/all/all_main.odin
+++ b/examples/all/all_main.odin
@@ -56,4 +56,16 @@ import unicode        "core:unicode"
 import utf8           "core:unicode/utf8"
 import utf16          "core:unicode/utf16"
 
+
+import glfw   "vendor:glfw"
+import gl     "vendor:OpenGL"
+import PM     "vendor:portmidi"
+import SDL    "vendor:sdl2"
+import IMG    "vendor:sdl2/image"
+import SDLNet "vendor:sdl2/net"
+import MIX    "vendor:sdl2/mixer"
+import TTF    "vendor:sdl2/ttf"
+import vk     "vendor:vulkan"
+
+
 main :: proc(){}
diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin
index 1a6eddd8d..949be3273 100644
--- a/examples/demo/demo.odin
+++ b/examples/demo/demo.odin
@@ -30,15 +30,15 @@ import "core:intrinsics"
 */
 
 the_basics :: proc() {
-	fmt.println("\n# the basics");
+	fmt.println("\n# the basics")
 
 	{ // The Basics
-		fmt.println("Hellope");
+		fmt.println("Hellope")
 
 		// Lexical elements and literals
 		// A comment
 
-		my_integer_variable: int; // A comment for documentaton
+		my_integer_variable: int // A comment for documentaton
 
 		// Multi-line comments begin with /* and end with */. Multi-line comments can
 		// also be nested (unlike in C):
@@ -53,16 +53,16 @@ the_basics :: proc() {
 		// String literals are enclosed in double quotes and character literals in single quotes.
 		// Special characters are escaped with a backslash \
 
-		some_string := "This is a string";
-		_ = 'A'; // unicode codepoint literal
-		_ = '\n';
-		_ = "C:\\Windows\\notepad.exe";
+		some_string := "This is a string"
+		_ = 'A' // unicode codepoint literal
+		_ = '\n'
+		_ = "C:\\Windows\\notepad.exe"
 		// Raw string literals are enclosed with single back ticks
-		_ = `C:\Windows\notepad.exe`;
+		_ = `C:\Windows\notepad.exe`
 
 		// The length of a string in bytes can be found using the built-in `len` procedure:
-		_ = len("Foo");
-		_ = len(some_string);
+		_ = len("Foo")
+		_ = len(some_string)
 
 
 		// Numbers
@@ -79,27 +79,27 @@ the_basics :: proc() {
 		// In Odin, if a numeric constant can be represented by a type without
 		// precision loss, it will automatically convert to that type.
 
-		x: int = 1.0; // A float literal but it can be represented by an integer without precision loss
+		x: int = 1.0 // A float literal but it can be represented by an integer without precision loss
 		// Constant literals are “untyped” which means that they can implicitly convert to a type.
 
-		y: int; // `y` is typed of type `int`
-		y = 1;  // `1` is an untyped integer literal which can implicitly convert to `int`
+		y: int // `y` is typed of type `int`
+		y = 1  // `1` is an untyped integer literal which can implicitly convert to `int`
 
-		z: f64; // `z` is typed of type `f64` (64-bit floating point number)
-		z = 1;  // `1` is an untyped integer literal which can be implicitly converted to `f64`
+		z: f64 // `z` is typed of type `f64` (64-bit floating point number)
+		z = 1  // `1` is an untyped integer literal which can be implicitly converted to `f64`
 				// No need for any suffixes or decimal places like in other languages
 				// CONSTANTS JUST WORK!!!
 
 
 		// Assignment statements
-		h: int = 123; // declares a new variable `h` with type `int` and assigns a value to it
-		h = 637; // assigns a new value to `h`
+		h: int = 123 // declares a new variable `h` with type `int` and assigns a value to it
+		h = 637 // assigns a new value to `h`
 
 		// `=` is the assignment operator
 
 		// You can assign multiple variables with it:
-		a, b := 1, "hello"; // declares `a` and `b` and infers the types from the assignments
-		b, a = "byte", 0;
+		a, b := 1, "hello" // declares `a` and `b` and infers the types from the assignments
+		b, a = "byte", 0
 
 		// Note: `:=` is two tokens, `:` and `=`. The following are equivalent,
 		/*
@@ -112,26 +112,26 @@ the_basics :: proc() {
 		// Constants are entities (symbols) which have an assigned value.
 		// The constant’s value cannot be changed.
 		// The constant’s value must be able to be evaluated at compile time:
-		X :: "what"; // constant `X` has the untyped string value "what"
+		X :: "what" // constant `X` has the untyped string value "what"
 
 		// Constants can be explicitly typed like a variable declaration:
-		Y : int : 123;
-		Z :: Y + 7; // constant computations are possible
+		Y : int : 123
+		Z :: Y + 7 // constant computations are possible
 
-		_ = my_integer_variable;
-		_ = x;
+		_ = my_integer_variable
+		_ = x
 	}
 }
 
 control_flow :: proc() {
-	fmt.println("\n# control flow");
+	fmt.println("\n# control flow")
 	{ // Control flow
 		// For loop
 		// Odin has only one loop statement, the `for` loop
 
 		// Basic for loop
 		for i := 0; i < 10; i += 1 {
-			fmt.println(i);
+			fmt.println(i)
 		}
 
 		// NOTE: Unlike other languages like C, there are no parentheses `( )` surrounding the three components.
@@ -140,104 +140,104 @@ control_flow :: proc() {
 		// for i := 0; i < 10; i += 1 do fmt.print();
 
 		// The initial and post statements are optional
-		i := 0;
+		i := 0
 		for ; i < 10; {
-			i += 1;
+			i += 1
 		}
 
 		// These semicolons can be dropped. This `for` loop is equivalent to C's `while` loop
-		i = 0;
+		i = 0
 		for i < 10 {
-			i += 1;
+			i += 1
 		}
 
 		// If the condition is omitted, an infinite loop is produced:
 		for {
-			break;
+			break
 		}
 
 		// Range-based for loop
 		// The basic for loop
 		for j := 0; j < 10; j += 1 {
-			fmt.println(j);
+			fmt.println(j)
 		}
 		// can also be written
 		for j in 0..<10 {
-			fmt.println(j);
+			fmt.println(j)
 		}
 		for j in 0..=9 {
-			fmt.println(j);
+			fmt.println(j)
 		}
 
 		// Certain built-in types can be iterated over
-		some_string := "Hello, 世界";
+		some_string := "Hello, 世界"
 		for character in some_string { // Strings are assumed to be UTF-8
-			fmt.println(character);
+			fmt.println(character)
 		}
 
-		some_array := [3]int{1, 4, 9};
+		some_array := [3]int{1, 4, 9}
 		for value in some_array {
-			fmt.println(value);
+			fmt.println(value)
 		}
 
-		some_slice := []int{1, 4, 9};
+		some_slice := []int{1, 4, 9}
 		for value in some_slice {
-			fmt.println(value);
+			fmt.println(value)
 		}
 
-		some_dynamic_array := [dynamic]int{1, 4, 9};
-		defer delete(some_dynamic_array);
+		some_dynamic_array := [dynamic]int{1, 4, 9}
+		defer delete(some_dynamic_array)
 		for value in some_dynamic_array {
-			fmt.println(value);
+			fmt.println(value)
 		}
 
 
-		some_map := map[string]int{"A" = 1, "C" = 9, "B" = 4};
-		defer delete(some_map);
+		some_map := map[string]int{"A" = 1, "C" = 9, "B" = 4}
+		defer delete(some_map)
 		for key in some_map {
-			fmt.println(key);
+			fmt.println(key)
 		}
 
 		// Alternatively a second index value can be added
 		for character, index in some_string {
-			fmt.println(index, character);
+			fmt.println(index, character)
 		}
 		for value, index in some_array {
-			fmt.println(index, value);
+			fmt.println(index, value)
 		}
 		for value, index in some_slice {
-			fmt.println(index, value);
+			fmt.println(index, value)
 		}
 		for value, index in some_dynamic_array {
-			fmt.println(index, value);
+			fmt.println(index, value)
 		}
 		for key, value in some_map {
-			fmt.println(key, value);
+			fmt.println(key, value)
 		}
 
 		// The iterated values are copies and cannot be written to.
 		// The following idiom is useful for iterating over a container in a by-reference manner:
 		for _, idx in some_slice {
-			some_slice[idx] = (idx+1)*(idx+1);
+			some_slice[idx] = (idx+1)*(idx+1)
 		}
 
 
 		// If statements
-		x := 123;
+		x := 123
 		if x >= 0 {
-			fmt.println("x is positive");
+			fmt.println("x is positive")
 		}
 
 		if y := -34; y < 0 {
-			fmt.println("y is negative");
+			fmt.println("y is negative")
 		}
 
 		if y := 123; y < 0 {
-			fmt.println("y is negative");
+			fmt.println("y is negative")
 		} else if y == 0 {
-			fmt.println("y is zero");
+			fmt.println("y is zero")
 		} else {
-			fmt.println("y is positive");
+			fmt.println("y is positive")
 		}
 
 		// Switch statement
@@ -246,11 +246,11 @@ control_flow :: proc() {
 
 		switch arch := ODIN_ARCH; arch {
 		case "386":
-			fmt.println("32-bit");
+			fmt.println("32-bit")
 		case "amd64":
-			fmt.println("64-bit");
+			fmt.println("64-bit")
 		case: // default
-			fmt.println("Unsupported architecture");
+			fmt.println("Unsupported architecture")
 		}
 
 		// Odin’s `switch` is like one in C or C++, except that Odin only runs the selected case.
@@ -259,8 +259,8 @@ control_flow :: proc() {
 
 		// To achieve a C-like fall through into the next case block, the keyword `fallthrough` can be used.
 		one_angry_dwarf :: proc() -> int {
-			fmt.println("one_angry_dwarf was called");
-			return 1;
+			fmt.println("one_angry_dwarf was called")
+			return 1
 		}
 
 		switch j := 0; j {
@@ -274,28 +274,28 @@ control_flow :: proc() {
 
 		switch {
 		case x < 0:
-			fmt.println("x is negative");
+			fmt.println("x is negative")
 		case x == 0:
-			fmt.println("x is zero");
+			fmt.println("x is zero")
 		case:
-			fmt.println("x is positive");
+			fmt.println("x is positive")
 		}
 
 		// A `switch` statement can also use ranges like a range-based loop:
 		switch c := 'j'; c {
 		case 'A'..='Z', 'a'..='z', '0'..='9':
-			fmt.println("c is alphanumeric");
+			fmt.println("c is alphanumeric")
 		}
 
 		switch x {
 		case 0..<10:
-			fmt.println("units");
+			fmt.println("units")
 		case 10..<13:
-			fmt.println("pre-teens");
+			fmt.println("pre-teens")
 		case 13..<20:
-			fmt.println("teens");
+			fmt.println("teens")
 		case 20..<30:
-			fmt.println("twenties");
+			fmt.println("twenties")
 		}
 	}
 
@@ -305,15 +305,15 @@ control_flow :: proc() {
 
 		// The following will print 4 then 234:
 		{
-			x := 123;
-			defer fmt.println(x);
+			x := 123
+			defer fmt.println(x)
 			{
-				defer x = 4;
-				x = 2;
+				defer x = 4
+				x = 2
 			}
-			fmt.println(x);
+			fmt.println(x)
 
-			x = 234;
+			x = 234
 		}
 
 		// You can defer an entire block too:
@@ -321,30 +321,30 @@ control_flow :: proc() {
 			bar :: proc() {}
 
 			defer {
-				fmt.println("1");
-				fmt.println("2");
+				fmt.println("1")
+				fmt.println("2")
 			}
 
-			cond := false;
+			cond := false
 			defer if cond {
-				bar();
+				bar()
 			}
 		}
 
 		// Defer statements are executed in the reverse order that they were declared:
 		{
-			defer fmt.println("1");
-			defer fmt.println("2");
-			defer fmt.println("3");
+			defer fmt.println("1")
+			defer fmt.println("2")
+			defer fmt.println("3")
 		}
 		// Will print 3, 2, and then 1.
 
 		if false {
-			f, err := os.open("my_file.txt");
+			f, err := os.open("my_file.txt")
 			if err != 0 {
 				// handle error
 			}
-			defer os.close(f);
+			defer os.close(f)
 			// rest of code
 		}
 	}
@@ -364,11 +364,11 @@ control_flow :: proc() {
 
 		// Example
 		when ODIN_ARCH == "386" {
-			fmt.println("32 bit");
+			fmt.println("32 bit")
 		} else when ODIN_ARCH == "amd64" {
-			fmt.println("64 bit");
+			fmt.println("64 bit")
 		} else {
-			fmt.println("Unsupported architecture");
+			fmt.println("Unsupported architecture")
 		}
 		// The when statement is very useful for writing platform specific code.
 		// This is akin to the #if construct in C’s preprocessor however, in Odin,
@@ -376,34 +376,34 @@ control_flow :: proc() {
 	}
 
 	{ // Branch statements
-		cond, cond1, cond2 := false, false, false;
-		one_step :: proc() { fmt.println("one_step"); }
-		beyond :: proc() { fmt.println("beyond"); }
+		cond, cond1, cond2 := false, false, false
+		one_step :: proc() { fmt.println("one_step") }
+		beyond :: proc() { fmt.println("beyond") }
 
 		// Break statement
 		for cond {
 			switch {
 			case:
 				if cond {
-					break; // break out of the `switch` statement
+					break // break out of the `switch` statement
 				}
 			}
 
-			break; // break out of the `for` statement
+			break // break out of the `for` statement
 		}
 
 		loop: for cond1 {
 			for cond2 {
-				break loop; // leaves both loops
+				break loop // leaves both loops
 			}
 		}
 
 		// Continue statement
 		for cond {
 			if cond2 {
-				continue;
+				continue
 			}
-			fmt.println("Hellope");
+			fmt.println("Hellope")
 		}
 
 		// Fallthrough statement
@@ -417,65 +417,65 @@ control_flow :: proc() {
 
 		switch i := 0; i {
 		case 0:
-			one_step();
-			fallthrough;
+			one_step()
+			fallthrough
 		case 1:
-			beyond();
+			beyond()
 		}
 	}
 }
 
 
 named_proc_return_parameters :: proc() {
-	fmt.println("\n# named proc return parameters");
+	fmt.println("\n# named proc return parameters")
 
 	foo0 :: proc() -> int {
-		return 123;
+		return 123
 	}
 	foo1 :: proc() -> (a: int) {
-		a = 123;
-		return;
+		a = 123
+		return
 	}
 	foo2 :: proc() -> (a, b: int) {
 		// Named return values act like variables within the scope
-		a = 321;
-		b = 567;
-		return b, a;
+		a = 321
+		b = 567
+		return b, a
 	}
-	fmt.println("foo0 =", foo0()); // 123
-	fmt.println("foo1 =", foo1()); // 123
-	fmt.println("foo2 =", foo2()); // 567 321
+	fmt.println("foo0 =", foo0()) // 123
+	fmt.println("foo1 =", foo1()) // 123
+	fmt.println("foo2 =", foo2()) // 567 321
 }
 
 
 explicit_procedure_overloading :: proc() {
-	fmt.println("\n# explicit procedure overloading");
+	fmt.println("\n# explicit procedure overloading")
 
 	add_ints :: proc(a, b: int) -> int {
-		x := a + b;
-		fmt.println("add_ints", x);
-		return x;
+		x := a + b
+		fmt.println("add_ints", x)
+		return x
 	}
 	add_floats :: proc(a, b: f32) -> f32 {
-		x := a + b;
-		fmt.println("add_floats", x);
-		return x;
+		x := a + b
+		fmt.println("add_floats", x)
+		return x
 	}
 	add_numbers :: proc(a: int, b: f32, c: u8) -> int {
-		x := int(a) + int(b) + int(c);
-		fmt.println("add_numbers", x);
-		return x;
+		x := int(a) + int(b) + int(c)
+		fmt.println("add_numbers", x)
+		return x
 	}
 
-	add :: proc{add_ints, add_floats, add_numbers};
+	add :: proc{add_ints, add_floats, add_numbers}
 
-	add(int(1), int(2));
-	add(f32(1), f32(2));
-	add(int(1), f32(2), u8(3));
+	add(int(1), int(2))
+	add(f32(1), f32(2))
+	add(int(1), f32(2), u8(3))
 
-	add(1, 2);     // untyped ints coerce to int tighter than f32
-	add(1.0, 2.0); // untyped floats coerce to f32 tighter than int
-	add(1, 2, 3);  // three parameters
+	add(1, 2)     // untyped ints coerce to int tighter than f32
+	add(1.0, 2.0) // untyped floats coerce to f32 tighter than int
+	add(1, 2, 3)  // three parameters
 
 	// Ambiguous answers
 	// add(1.0, 2);
@@ -483,24 +483,24 @@ explicit_procedure_overloading :: proc() {
 }
 
 struct_type :: proc() {
-	fmt.println("\n# struct type");
+	fmt.println("\n# struct type")
 	// A struct is a record type in Odin. It is a collection of fields.
 	// Struct fields are accessed by using a dot:
 	{
 		Vector2 :: struct {
 			x: f32,
 			y: f32,
-		};
-		v := Vector2{1, 2};
-		v.x = 4;
-		fmt.println(v.x);
+		}
+		v := Vector2{1, 2}
+		v.x = 4
+		fmt.println(v.x)
 
 		// Struct fields can be accessed through a struct pointer:
 
-		v = Vector2{1, 2};
-		p := &v;
-		p.x = 1335;
-		fmt.println(v);
+		v = Vector2{1, 2}
+		p := &v
+		p.x = 1335
+		fmt.println(v)
 
 		// We could write p^.x, however, it is to nice abstract the ability
 		// to not explicitly dereference the pointer. This is very useful when
@@ -512,46 +512,46 @@ struct_type :: proc() {
 		// arguments or none:
 		Vector3 :: struct {
 			x, y, z: f32,
-		};
-		v: Vector3;
-		v = Vector3{}; // Zero value
-		v = Vector3{1, 4, 9};
+		}
+		v: Vector3
+		v = Vector3{} // Zero value
+		v = Vector3{1, 4, 9}
 
 		// You can list just a subset of the fields if you specify the
 		// field by name (the order of the named fields does not matter):
-		v = Vector3{z=1, y=2};
-		assert(v.x == 0);
-		assert(v.y == 2);
-		assert(v.z == 1);
+		v = Vector3{z=1, y=2}
+		assert(v.x == 0)
+		assert(v.y == 2)
+		assert(v.z == 1)
 	}
 	{
 		// Structs can tagged with different memory layout and alignment requirements:
 
-		a :: struct #align 4   {}; // align to 4 bytes
-		b :: struct #packed    {}; // remove padding between fields
-		c :: struct #raw_union {}; // all fields share the same offset (0). This is the same as C's union
+		a :: struct #align 4   {} // align to 4 bytes
+		b :: struct #packed    {} // remove padding between fields
+		c :: struct #raw_union {} // all fields share the same offset (0). This is the same as C's union
 	}
 
 }
 
 
 union_type :: proc() {
-	fmt.println("\n# union type");
+	fmt.println("\n# union type")
 	{
-		val: union{int, bool};
-		val = 137;
+		val: union{int, bool}
+		val = 137
 		if i, ok := val.(int); ok {
-			fmt.println(i);
+			fmt.println(i)
 		}
-		val = true;
-		fmt.println(val);
+		val = true
+		fmt.println(val)
 
-		val = nil;
+		val = nil
 
 		switch v in val {
-		case int:  fmt.println("int",  v);
-		case bool: fmt.println("bool", v);
-		case:      fmt.println("nil");
+		case int:  fmt.println("int",  v)
+		case bool: fmt.println("bool", v)
+		case:      fmt.println("nil")
 		}
 	}
 	{
@@ -559,25 +559,25 @@ union_type :: proc() {
 		// An `any` has a pointer to the data and allows for any type (open)
 		// A `union` has as binary blob to store the data and allows only certain types (closed)
 		// The following code is with `any` but has the same syntax
-		val: any;
-		val = 137;
+		val: any
+		val = 137
 		if i, ok := val.(int); ok {
-			fmt.println(i);
+			fmt.println(i)
 		}
-		val = true;
-		fmt.println(val);
+		val = true
+		fmt.println(val)
 
-		val = nil;
+		val = nil
 
 		switch v in val {
-		case int:  fmt.println("int",  v);
-		case bool: fmt.println("bool", v);
-		case:      fmt.println("nil");
+		case int:  fmt.println("int",  v)
+		case bool: fmt.println("bool", v)
+		case:      fmt.println("nil")
 		}
 	}
 
-	Vector3 :: distinct [3]f32;
-	Quaternion :: distinct quaternion128;
+	Vector3 :: distinct [3]f32
+	Quaternion :: distinct quaternion128
 
 	// More realistic examples
 	{
@@ -594,35 +594,35 @@ union_type :: proc() {
 			orientation: Quaternion,
 
 			derived: any,
-		};
+		}
 
 		Frog :: struct {
 			using entity: Entity,
 			jump_height:  f32,
-		};
+		}
 
 		Monster :: struct {
 			using entity: Entity,
 			is_robot:     bool,
 			is_zombie:    bool,
-		};
+		}
 
 		// See `parametric_polymorphism` procedure for details
 		new_entity :: proc($T: typeid) -> ^Entity {
-			t := new(T);
-			t.derived = t^;
-			return t;
+			t := new(T)
+			t.derived = t^
+			return t
 		}
 
-		entity := new_entity(Monster);
+		entity := new_entity(Monster)
 
 		switch e in entity.derived {
 		case Frog:
-			fmt.println("Ribbit");
+			fmt.println("Ribbit")
 		case Monster:
-			if e.is_robot  { fmt.println("Robotic"); }
-			if e.is_zombie { fmt.println("Grrrr!");  }
-			fmt.println("I'm a monster");
+			if e.is_robot  { fmt.println("Robotic") }
+			if e.is_zombie { fmt.println("Grrrr!")  }
+			fmt.println("I'm a monster")
 		}
 	}
 
@@ -639,34 +639,34 @@ union_type :: proc() {
 			orientation: Quaternion,
 
 			derived: union {Frog, Monster},
-		};
+		}
 
 		Frog :: struct {
 			using entity: ^Entity,
 			jump_height:  f32,
-		};
+		}
 
 		Monster :: struct {
 			using entity: ^Entity,
 			is_robot:     bool,
 			is_zombie:    bool,
-		};
+		}
 
 		// See `parametric_polymorphism` procedure for details
 		new_entity :: proc($T: typeid) -> ^Entity {
-			t := new(Entity);
-			t.derived = T{entity = t};
-			return t;
+			t := new(Entity)
+			t.derived = T{entity = t}
+			return t
 		}
 
-		entity := new_entity(Monster);
+		entity := new_entity(Monster)
 
 		switch e in entity.derived {
 		case Frog:
-			fmt.println("Ribbit");
+			fmt.println("Ribbit")
 		case Monster:
-			if e.is_robot  { fmt.println("Robotic"); }
-			if e.is_zombie { fmt.println("Grrrr!");  }
+			if e.is_robot  { fmt.println("Robotic") }
+			if e.is_zombie { fmt.println("Grrrr!")  }
 		}
 
 		// NOTE(bill): As you can see, the usage code has not changed, only its
@@ -710,38 +710,38 @@ union_type :: proc() {
 }
 
 using_statement :: proc() {
-	fmt.println("\n# using statement");
+	fmt.println("\n# using statement")
 	// using can used to bring entities declared in a scope/namespace
 	// into the current scope. This can be applied to import names, struct
 	// fields, procedure fields, and struct values.
 
-	Vector3 :: struct{x, y, z: f32};
+	Vector3 :: struct{x, y, z: f32}
 	{
 		Entity :: struct {
 			position: Vector3,
 			orientation: quaternion128,
-		};
+		}
 
 		// It can used like this:
 		foo0 :: proc(entity: ^Entity) {
-			fmt.println(entity.position.x, entity.position.y, entity.position.z);
+			fmt.println(entity.position.x, entity.position.y, entity.position.z)
 		}
 
 		// The entity members can be brought into the procedure scope by using it:
 		foo1 :: proc(entity: ^Entity) {
-			using entity;
-			fmt.println(position.x, position.y, position.z);
+			using entity
+			fmt.println(position.x, position.y, position.z)
 		}
 
 		// The using can be applied to the parameter directly:
 		foo2 :: proc(using entity: ^Entity) {
-			fmt.println(position.x, position.y, position.z);
+			fmt.println(position.x, position.y, position.z)
 		}
 
 		// It can also be applied to sub-fields:
 		foo3 :: proc(entity: ^Entity) {
-			using entity.position;
-			fmt.println(x, y, z);
+			using entity.position
+			fmt.println(x, y, z)
 		}
 	}
 	{
@@ -750,9 +750,9 @@ using_statement :: proc() {
 		Entity :: struct {
 			using position: Vector3,
 			orientation: quaternion128,
-		};
+		}
 		foo :: proc(entity: ^Entity) {
-			fmt.println(entity.x, entity.y, entity.z);
+			fmt.println(entity.x, entity.y, entity.z)
 		}
 
 
@@ -761,18 +761,18 @@ using_statement :: proc() {
 		// functionality in C++, but without the requirement of vtables or unknown
 		// struct layout:
 
-		Colour :: struct {r, g, b, a: u8};
+		Colour :: struct {r, g, b, a: u8}
 		Frog :: struct {
 			ribbit_volume: f32,
 			using entity: Entity,
 			colour: Colour,
-		};
+		}
 
-		frog: Frog;
+		frog: Frog
 		// Both work
-		foo(&frog.entity);
-		foo(&frog);
-		frog.x = 123;
+		foo(&frog.entity)
+		foo(&frog)
+		frog.x = 123
 
 		// Note: using can be applied to arbitrarily many things, which allows
 		// the ability to have multiple subtype polymorphism (but also its issues).
@@ -783,7 +783,7 @@ using_statement :: proc() {
 
 
 implicit_context_system :: proc() {
-	fmt.println("\n# implicit context system");
+	fmt.println("\n# implicit context system")
 	// In each scope, there is an implicit value named context. This
 	// context variable is local to each scope and is implicitly passed
 	// by pointer to any procedure call in that scope (if the procedure
@@ -799,34 +799,34 @@ implicit_context_system :: proc() {
 	// third-party code to see what it does and to change how it does it is
 	// not possible.
 
-	c := context; // copy the current scope's context
+	c := context // copy the current scope's context
 
-	context.user_index = 456;
+	context.user_index = 456
 	{
-		context.allocator = my_custom_allocator();
-		context.user_index = 123;
-		what_a_fool_believes(); // the `context` for this scope is implicitly passed to `what_a_fool_believes`
+		context.allocator = my_custom_allocator()
+		context.user_index = 123
+		what_a_fool_believes() // the `context` for this scope is implicitly passed to `what_a_fool_believes`
 	}
 
 	// `context` value is local to the scope it is in
-	assert(context.user_index == 456);
+	assert(context.user_index == 456)
 
 	what_a_fool_believes :: proc() {
-		c := context; // this `context` is the same as the parent procedure that it was called from
+		c := context // this `context` is the same as the parent procedure that it was called from
 		// From this example, context.user_index == 123
 		// An context.allocator is assigned to the return value of `my_custom_allocator()`
-		assert(context.user_index == 123);
+		assert(context.user_index == 123)
 
 		// The memory management procedure use the `context.allocator` by
 		// default unless explicitly specified otherwise
-		china_grove := new(int);
-		free(china_grove);
+		china_grove := new(int)
+		free(china_grove)
 
-		_ = c;
+		_ = c
 	}
 
-	my_custom_allocator :: mem.nil_allocator;
-	_ = c;
+	my_custom_allocator :: mem.nil_allocator
+	_ = c
 
 	// By default, the context value has default values for its parameters which is
 	// decided in the package runtime. What the defaults are are compiler specific.
@@ -836,55 +836,55 @@ implicit_context_system :: proc() {
 }
 
 parametric_polymorphism :: proc() {
-	fmt.println("\n# parametric polymorphism");
+	fmt.println("\n# parametric polymorphism")
 
 	print_value :: proc(value: $T) {
-		fmt.printf("print_value: %T %v\n", value, value);
+		fmt.printf("print_value: %T %v\n", value, value)
 	}
 
-	v1: int    = 1;
-	v2: f32    = 2.1;
-	v3: f64    = 3.14;
-	v4: string = "message";
+	v1: int    = 1
+	v2: f32    = 2.1
+	v3: f64    = 3.14
+	v4: string = "message"
 
-	print_value(v1);
-	print_value(v2);
-	print_value(v3);
-	print_value(v4);
+	print_value(v1)
+	print_value(v2)
+	print_value(v3)
+	print_value(v4)
 
-	fmt.println();
+	fmt.println()
 
 	add :: proc(p, q: $T) -> T {
-		x: T = p + q;
-		return x;
+		x: T = p + q
+		return x
 	}
 
-	a := add(3, 4);
-	fmt.printf("a: %T = %v\n", a, a);
+	a := add(3, 4)
+	fmt.printf("a: %T = %v\n", a, a)
 
-	b := add(3.2, 4.3);
-	fmt.printf("b: %T = %v\n", b, b);
+	b := add(3.2, 4.3)
+	fmt.printf("b: %T = %v\n", b, b)
 
 	// This is how `new` is implemented
 	alloc_type :: proc($T: typeid) -> ^T {
-		t := cast(^T)alloc(size_of(T), align_of(T));
-		t^ = T{}; // Use default initialization value
-		return t;
+		t := cast(^T)alloc(size_of(T), align_of(T))
+		t^ = T{} // Use default initialization value
+		return t
 	}
 
 	copy_slice :: proc(dst, src: []$T) -> int {
-		n := min(len(dst), len(src));
+		n := min(len(dst), len(src))
 		if n > 0 {
-			mem.copy(&dst[0], &src[0], n*size_of(T));
+			mem.copy(&dst[0], &src[0], n*size_of(T))
 		}
-		return n;
+		return n
 	}
 
 	double_params :: proc(a: $A, b: $B) -> A {
-		return a + A(b);
+		return a + A(b)
 	}
 
-	fmt.println(double_params(12, 1.345));
+	fmt.println(double_params(12, 1.345))
 
 
 
@@ -894,46 +894,46 @@ parametric_polymorphism :: proc() {
 			hash:     u32,
 			key:      Key,
 			value:    Value,
-		};
-		TABLE_SIZE_MIN :: 32;
+		}
+		TABLE_SIZE_MIN :: 32
 		Table :: struct($Key, $Value: typeid) {
 			count:     int,
 			allocator: mem.Allocator,
 			slots:     []Table_Slot(Key, Value),
-		};
+		}
 
 		// Only allow types that are specializations of a (polymorphic) slice
 		make_slice :: proc($T: typeid/[]$E, len: int) -> T {
-			return make(T, len);
+			return make(T, len)
 		}
 
 		// Only allow types that are specializations of `Table`
 		allocate :: proc(table: ^$T/Table, capacity: int) {
-			c := context;
+			c := context
 			if table.allocator.procedure != nil {
-				c.allocator = table.allocator;
+				c.allocator = table.allocator
 			}
-			context = c;
+			context = c
 
-			table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN));
+			table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN))
 		}
 
 		expand :: proc(table: ^$T/Table) {
-			c := context;
+			c := context
 			if table.allocator.procedure != nil {
-				c.allocator = table.allocator;
+				c.allocator = table.allocator
 			}
-			context = c;
+			context = c
 
-			old_slots := table.slots;
-			defer delete(old_slots);
+			old_slots := table.slots
+			defer delete(old_slots)
 
-			cap := max(2*len(table.slots), TABLE_SIZE_MIN);
-			allocate(table, cap);
+			cap := max(2*len(table.slots), TABLE_SIZE_MIN)
+			allocate(table, cap)
 
 			for s in old_slots {
 				if s.occupied {
-					put(table, s.key, s.value);
+					put(table, s.key, s.value)
 				}
 			}
 		}
@@ -941,83 +941,83 @@ parametric_polymorphism :: proc() {
 		// Polymorphic determination of a polymorphic struct
 		// put :: proc(table: ^$T/Table, key: T.Key, value: T.Value) {
 		put :: proc(table: ^Table($Key, $Value), key: Key, value: Value) {
-			hash := get_hash(key); // Ad-hoc method which would fail in a different scope
-			index := find_index(table, key, hash);
+			hash := get_hash(key) // Ad-hoc method which would fail in a different scope
+			index := find_index(table, key, hash)
 			if index < 0 {
 				if f64(table.count) >= 0.75*f64(len(table.slots)) {
-					expand(table);
+					expand(table)
 				}
-				assert(table.count <= len(table.slots));
+				assert(table.count <= len(table.slots))
 
-				index = int(hash % u32(len(table.slots)));
+				index = int(hash % u32(len(table.slots)))
 
 				for table.slots[index].occupied {
 					if index += 1; index >= len(table.slots) {
-						index = 0;
+						index = 0
 					}
 				}
 
-				table.count += 1;
+				table.count += 1
 			}
 
-			slot := &table.slots[index];
-			slot.occupied = true;
-			slot.hash     = hash;
-			slot.key      = key;
-			slot.value    = value;
+			slot := &table.slots[index]
+			slot.occupied = true
+			slot.hash     = hash
+			slot.key      = key
+			slot.value    = value
 		}
 
 
 		// find :: proc(table: ^$T/Table, key: T.Key) -> (T.Value, bool) {
 		find :: proc(table: ^Table($Key, $Value), key: Key) -> (Value, bool) {
-			hash := get_hash(key);
-			index := find_index(table, key, hash);
+			hash := get_hash(key)
+			index := find_index(table, key, hash)
 			if index < 0 {
-				return Value{}, false;
+				return Value{}, false
 			}
-			return table.slots[index].value, true;
+			return table.slots[index].value, true
 		}
 
 		find_index :: proc(table: ^Table($Key, $Value), key: Key, hash: u32) -> int {
 			if len(table.slots) <= 0 {
-				return -1;
+				return -1
 			}
 
-			index := int(hash % u32(len(table.slots)));
+			index := int(hash % u32(len(table.slots)))
 			for table.slots[index].occupied {
 				if table.slots[index].hash == hash {
 					if table.slots[index].key == key {
-						return index;
+						return index
 					}
 				}
 
 				if index += 1; index >= len(table.slots) {
-					index = 0;
+					index = 0
 				}
 			}
 
-			return -1;
+			return -1
 		}
 
 		get_hash :: proc(s: string) -> u32 { // fnv32a
-			h: u32 = 0x811c9dc5;
+			h: u32 = 0x811c9dc5
 			for i in 0..<len(s) {
-				h = (h ~ u32(s[i])) * 0x01000193;
+				h = (h ~ u32(s[i])) * 0x01000193
 			}
-			return h;
+			return h
 		}
 
 
-		table: Table(string, int);
+		table: Table(string, int)
 
-		for i in 0..=36 { put(&table, "Hellope", i); }
-		for i in 0..=42 { put(&table, "World!",  i); }
+		for i in 0..=36 { put(&table, "Hellope", i) }
+		for i in 0..=42 { put(&table, "World!",  i) }
 
-		found, _ := find(&table, "Hellope");
-		fmt.printf("`found` is %v\n", found);
+		found, _ := find(&table, "Hellope")
+		fmt.printf("`found` is %v\n", found)
 
-		found, _ = find(&table, "World!");
-		fmt.printf("`found` is %v\n", found);
+		found, _ = find(&table, "World!")
+		fmt.printf("`found` is %v\n", found)
 
 		// I would not personally design a hash table like this in production
 		// but this is a nice basic example
@@ -1032,16 +1032,16 @@ parametric_polymorphism :: proc() {
 			Foo1,
 			Foo2,
 			Foo3,
-		};
-		Para_Union :: union($T: typeid) {T, Error};
-		r: Para_Union(int);
-		fmt.println(typeid_of(type_of(r)));
+		}
+		Para_Union :: union($T: typeid) {T, Error}
+		r: Para_Union(int)
+		fmt.println(typeid_of(type_of(r)))
 
-		fmt.println(r);
-		r = 123;
-		fmt.println(r);
-		r = Error.Foo0; // r = .Foo0; is allow too, see implicit selector expressions below
-		fmt.println(r);
+		fmt.println(r)
+		r = 123
+		fmt.println(r)
+		r = Error.Foo0 // r = .Foo0; is allow too, see implicit selector expressions below
+		fmt.println(r)
 	}
 
 	{ // Polymorphic names
@@ -1050,17 +1050,17 @@ parametric_polymorphism :: proc() {
 			// `I` is the type of N
 			// `T` is the type passed
 			fmt.printf("Generating an array of type %v from the value %v of type %v\n",
-					   typeid_of(type_of(res)), N, typeid_of(I));
+					   typeid_of(type_of(res)), N, typeid_of(I))
 			for i in 0..<N {
-				res[i] = T(i*i);
+				res[i] = T(i*i)
 			}
-			return;
+			return
 		}
 
-		T :: int;
-		array := foo(4, T);
+		T :: int
+		array := foo(4, T)
 		for v, i in array {
-			assert(v == T(i*i));
+			assert(v == T(i*i))
 		}
 
 		// Matrix multiplication
@@ -1068,24 +1068,24 @@ parametric_polymorphism :: proc() {
 			for i in 0..<M {
 				for j in 0..<P {
 					for k in 0..<N {
-						c[i][j] += a[i][k] * b[k][j];
+						c[i][j] += a[i][k] * b[k][j]
 					}
 				}
 			}
-			return;
+			return
 		}
 
 		x := [2][3]f32{
 			{1, 2, 3},
 			{3, 2, 1},
-		};
+		}
 		y := [3][2]f32{
 			{0, 8},
 			{6, 2},
 			{8, 4},
-		};
-		z := mul(x, y);
-		assert(z == {{36, 24}, {20, 32}});
+		}
+		z := mul(x, y)
+		assert(z == {{36, 24}, {20, 32}})
 	}
 }
 
@@ -1097,241 +1097,241 @@ prefix_table := [?]string{
 	"Blue",
 	"Octarine",
 	"Black",
-};
+}
 
 threading_example :: proc() {
 	if ODIN_OS == "darwin" {
 		// TODO: Fix threads on darwin/macOS
-		return;
+		return
 	}
 
-	fmt.println("\n# threading_example");
+	fmt.println("\n# threading_example")
 
 	{ // Basic Threads
-		fmt.println("\n## Basic Threads");
+		fmt.println("\n## Basic Threads")
 			worker_proc :: proc(t: ^thread.Thread) {
 			for iteration in 1..=5 {
-				fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration);
-				fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration);
-				time.sleep(1 * time.Millisecond);
+				fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration)
+				fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration)
+				time.sleep(1 * time.Millisecond)
 			}
 		}
 
-		threads := make([dynamic]^thread.Thread, 0, len(prefix_table));
-		defer delete(threads);
+		threads := make([dynamic]^thread.Thread, 0, len(prefix_table))
+		defer delete(threads)
 
 		for in prefix_table {
 			if t := thread.create(worker_proc); t != nil {
-				t.init_context = context;
-				t.user_index = len(threads);
-				append(&threads, t);
-				thread.start(t);
+				t.init_context = context
+				t.user_index = len(threads)
+				append(&threads, t)
+				thread.start(t)
 			}
 		}
 
 		for len(threads) > 0 {
 			for i := 0; i < len(threads); /**/ {
 				if t := threads[i]; thread.is_done(t) {
-					fmt.printf("Thread %d is done\n", t.user_index);
-					thread.destroy(t);
+					fmt.printf("Thread %d is done\n", t.user_index)
+					thread.destroy(t)
 
-					ordered_remove(&threads, i);
+					ordered_remove(&threads, i)
 				} else {
-					i += 1;
+					i += 1
 				}
 			}
 		}
 	}
 
 	{ // Thread Pool
-		fmt.println("\n## Thread Pool");
+		fmt.println("\n## Thread Pool")
 		task_proc :: proc(t: ^thread.Task) {
-			index := t.user_index % len(prefix_table);
+			index := t.user_index % len(prefix_table)
 			for iteration in 1..=5 {
-				fmt.printf("Worker Task %d is on iteration %d\n", t.user_index, iteration);
-				fmt.printf("`%s`: iteration %d\n", prefix_table[index], iteration);
-				time.sleep(1 * time.Millisecond);
+				fmt.printf("Worker Task %d is on iteration %d\n", t.user_index, iteration)
+				fmt.printf("`%s`: iteration %d\n", prefix_table[index], iteration)
+				time.sleep(1 * time.Millisecond)
 			}
 		}
 
-		pool: thread.Pool;
-		thread.pool_init(pool=&pool, thread_count=3);
-		defer thread.pool_destroy(&pool);
+		pool: thread.Pool
+		thread.pool_init(pool=&pool, thread_count=3)
+		defer thread.pool_destroy(&pool)
 
 
 		for i in 0..<30 {
-			thread.pool_add_task(pool=&pool, procedure=task_proc, data=nil, user_index=i);
+			thread.pool_add_task(pool=&pool, procedure=task_proc, data=nil, user_index=i)
 		}
 
-		thread.pool_start(&pool);
-		thread.pool_wait_and_process(&pool);
+		thread.pool_start(&pool)
+		thread.pool_wait_and_process(&pool)
 	}
 }
 
 
 array_programming :: proc() {
-	fmt.println("\n# array programming");
+	fmt.println("\n# array programming")
 	{
-		a := [3]f32{1, 2, 3};
-		b := [3]f32{5, 6, 7};
-		c := a * b;
-		d := a + b;
-		e := 1 +  (c - d) / 2;
-		fmt.printf("%.1f\n", e); // [0.5, 3.0, 6.5]
+		a := [3]f32{1, 2, 3}
+		b := [3]f32{5, 6, 7}
+		c := a * b
+		d := a + b
+		e := 1 +  (c - d) / 2
+		fmt.printf("%.1f\n", e) // [0.5, 3.0, 6.5]
 	}
 
 	{
-		a := [3]f32{1, 2, 3};
-		b := swizzle(a, 2, 1, 0);
-		assert(b == [3]f32{3, 2, 1});
+		a := [3]f32{1, 2, 3}
+		b := swizzle(a, 2, 1, 0)
+		assert(b == [3]f32{3, 2, 1})
 
-		c := swizzle(a, 0, 0);
-		assert(c == [2]f32{1, 1});
-		assert(c == 1);
+		c := swizzle(a, 0, 0)
+		assert(c == [2]f32{1, 1})
+		assert(c == 1)
 	}
 
 	{
-		Vector3 :: distinct [3]f32;
-		a := Vector3{1, 2, 3};
-		b := Vector3{5, 6, 7};
-		c := (a * b)/2 + 1;
-		d := c.x + c.y + c.z;
-		fmt.printf("%.1f\n", d); // 22.0
+		Vector3 :: distinct [3]f32
+		a := Vector3{1, 2, 3}
+		b := Vector3{5, 6, 7}
+		c := (a * b)/2 + 1
+		d := c.x + c.y + c.z
+		fmt.printf("%.1f\n", d) // 22.0
 
 		cross :: proc(a, b: Vector3) -> Vector3 {
-			i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1);
-			j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0);
-			return i - j;
+			i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1)
+			j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0)
+			return i - j
 		}
 
 		cross_shorter :: proc(a, b: Vector3) -> Vector3 {
-			i := a.yzx * b.zxy;
-			j := a.zxy * b.yzx;
-			return i - j;
+			i := a.yzx * b.zxy
+			j := a.zxy * b.yzx
+			return i - j
 		}
 
 		blah :: proc(a: Vector3) -> f32 {
-			return a.x + a.y + a.z;
+			return a.x + a.y + a.z
 		}
 
-		x := cross(a, b);
-		fmt.println(x);
-		fmt.println(blah(x));
+		x := cross(a, b)
+		fmt.println(x)
+		fmt.println(blah(x))
 	}
 }
 
 map_type :: proc() {
-	fmt.println("\n# map type");
+	fmt.println("\n# map type")
 
-	m := make(map[string]int);
-	defer delete(m);
+	m := make(map[string]int)
+	defer delete(m)
 
-	m["Bob"] = 2;
-	m["Ted"] = 5;
-	fmt.println(m["Bob"]);
+	m["Bob"] = 2
+	m["Ted"] = 5
+	fmt.println(m["Bob"])
 
-	delete_key(&m, "Ted");
+	delete_key(&m, "Ted")
 
 	// If an element of a key does not exist, the zero value of the
 	// element will be returned. To check to see if an element exists
 	// can be done in two ways:
-	elem, ok := m["Bob"];
-	exists := "Bob" in m;
-	_, _ = elem, ok;
-	_ = exists;
+	elem, ok := m["Bob"]
+	exists := "Bob" in m
+	_, _ = elem, ok
+	_ = exists
 }
 
 implicit_selector_expression :: proc() {
-	fmt.println("\n# implicit selector expression");
+	fmt.println("\n# implicit selector expression")
 
-	Foo :: enum {A, B, C};
+	Foo :: enum {A, B, C}
 
-	f: Foo;
-	f = Foo.A;
-	f = .A;
+	f: Foo
+	f = Foo.A
+	f = .A
 
-	BAR :: bit_set[Foo]{.B, .C};
+	BAR :: bit_set[Foo]{.B, .C}
 
 	switch f {
 	case .A:
-		fmt.println("HITHER");
+		fmt.println("HITHER")
 	case .B:
-		fmt.println("NEVER");
+		fmt.println("NEVER")
 	case .C:
-		fmt.println("FOREVER");
+		fmt.println("FOREVER")
 	}
 
-	my_map := make(map[Foo]int);
-	defer delete(my_map);
+	my_map := make(map[Foo]int)
+	defer delete(my_map)
 
-	my_map[.A] = 123;
-	my_map[Foo.B] = 345;
+	my_map[.A] = 123
+	my_map[Foo.B] = 345
 
-	fmt.println(my_map[.A] + my_map[Foo.B] + my_map[.C]);
+	fmt.println(my_map[.A] + my_map[Foo.B] + my_map[.C])
 }
 
 
 partial_switch :: proc() {
-	fmt.println("\n# partial_switch");
+	fmt.println("\n# partial_switch")
 	{ // enum
 		Foo :: enum {
 			A,
 			B,
 			C,
 			D,
-		};
+		}
 
-		f := Foo.A;
+		f := Foo.A
 		switch f {
-		case .A: fmt.println("A");
-		case .B: fmt.println("B");
-		case .C: fmt.println("C");
-		case .D: fmt.println("D");
-		case:    fmt.println("?");
+		case .A: fmt.println("A")
+		case .B: fmt.println("B")
+		case .C: fmt.println("C")
+		case .D: fmt.println("D")
+		case:    fmt.println("?")
 		}
 
 		#partial switch f {
-		case .A: fmt.println("A");
-		case .D: fmt.println("D");
+		case .A: fmt.println("A")
+		case .D: fmt.println("D")
 		}
 	}
 	{ // union
-		Foo :: union {int, bool};
-		f: Foo = 123;
+		Foo :: union {int, bool}
+		f: Foo = 123
 		switch in f {
-		case int:  fmt.println("int");
-		case bool: fmt.println("bool");
+		case int:  fmt.println("int")
+		case bool: fmt.println("bool")
 		case:
 		}
 
 		#partial switch in f {
-		case bool: fmt.println("bool");
+		case bool: fmt.println("bool")
 		}
 	}
 }
 
 cstring_example :: proc() {
-	fmt.println("\n# cstring_example");
-
-	W :: "Hellope";
-	X :: cstring(W);
-	Y :: string(X);
-
-	w := W;
-	_ = w;
-	x: cstring = X;
-	y: string = Y;
-	z := string(x);
-	fmt.println(x, y, z);
-	fmt.println(len(x), len(y), len(z));
-	fmt.println(len(W), len(X), len(Y));
+	fmt.println("\n# cstring_example")
+
+	W :: "Hellope"
+	X :: cstring(W)
+	Y :: string(X)
+
+	w := W
+	_ = w
+	x: cstring = X
+	y: string = Y
+	z := string(x)
+	fmt.println(x, y, z)
+	fmt.println(len(x), len(y), len(z))
+	fmt.println(len(W), len(X), len(Y))
 	// IMPORTANT NOTE for cstring variables
 	// len(cstring) is O(N)
 	// cast(string)cstring is O(N)
 }
 
 bit_set_type :: proc() {
-	fmt.println("\n# bit_set type");
+	fmt.println("\n# bit_set type")
 
 	{
 		Day :: enum {
@@ -1342,177 +1342,177 @@ bit_set_type :: proc() {
 			Thursday,
 			Friday,
 			Saturday,
-		};
+		}
 
-		Days :: distinct bit_set[Day];
-		WEEKEND :: Days{.Sunday, .Saturday};
+		Days :: distinct bit_set[Day]
+		WEEKEND :: Days{.Sunday, .Saturday}
 
-		d: Days;
-		d = {.Sunday, .Monday};
-		e := d + WEEKEND;
-		e += {.Monday};
-		fmt.println(d, e);
+		d: Days
+		d = {.Sunday, .Monday}
+		e := d + WEEKEND
+		e += {.Monday}
+		fmt.println(d, e)
 
-		ok := .Saturday in e; // `in` is only allowed for `map` and `bit_set` types
-		fmt.println(ok);
+		ok := .Saturday in e // `in` is only allowed for `map` and `bit_set` types
+		fmt.println(ok)
 		if .Saturday in e {
-			fmt.println("Saturday in", e);
+			fmt.println("Saturday in", e)
 		}
-		X :: .Saturday in WEEKEND; // Constant evaluation
-		fmt.println(X);
-		fmt.println("Cardinality:", card(e));
+		X :: .Saturday in WEEKEND // Constant evaluation
+		fmt.println(X)
+		fmt.println("Cardinality:", card(e))
 	}
 	{
-		x: bit_set['A'..='Z'];
+		x: bit_set['A'..='Z']
 		#assert(size_of(x) == size_of(u32));
-		y: bit_set[0..=8; u16];
-		fmt.println(typeid_of(type_of(x))); // bit_set[A..=Z]
-		fmt.println(typeid_of(type_of(y))); // bit_set[0..=8; u16]
+		y: bit_set[0..=8; u16]
+		fmt.println(typeid_of(type_of(x))) // bit_set[A..=Z]
+		fmt.println(typeid_of(type_of(y))) // bit_set[0..=8; u16]
 
-		x += {'F'};
-		assert('F' in x);
-		x -= {'F'};
-		assert('F' not_in x);
+		x += {'F'}
+		assert('F' in x)
+		x -= {'F'}
+		assert('F' not_in x)
 
-		y += {1, 4, 2};
-		assert(2 in y);
+		y += {1, 4, 2}
+		assert(2 in y)
 	}
 	{
-		Letters :: bit_set['A'..='Z'];
-		a := Letters{'A', 'B'};
-		b := Letters{'A', 'B', 'C', 'D', 'F'};
-		c := Letters{'A', 'B'};
+		Letters :: bit_set['A'..='Z']
+		a := Letters{'A', 'B'}
+		b := Letters{'A', 'B', 'C', 'D', 'F'}
+		c := Letters{'A', 'B'}
 
-		assert(a <= b); // 'a' is a subset of 'b'
-		assert(b >= a); // 'b' is a superset of 'a'
-		assert(a < b);  // 'a' is a strict subset of 'b'
-		assert(b > a);  // 'b' is a strict superset of 'a'
+		assert(a <= b) // 'a' is a subset of 'b'
+		assert(b >= a) // 'b' is a superset of 'a'
+		assert(a < b)  // 'a' is a strict subset of 'b'
+		assert(b > a)  // 'b' is a strict superset of 'a'
 
-		assert(!(a < c)); // 'a' is a not strict subset of 'c'
-		assert(!(c > a)); // 'c' is a not strict superset of 'a'
+		assert(!(a < c)) // 'a' is a not strict subset of 'c'
+		assert(!(c > a)) // 'c' is a not strict superset of 'a'
 	}
 }
 
 deferred_procedure_associations :: proc() {
-	fmt.println("\n# deferred procedure associations");
+	fmt.println("\n# deferred procedure associations")
 
 	@(deferred_out=closure)
 	open :: proc(s: string) -> bool {
-		fmt.println(s);
-		return true;
+		fmt.println(s)
+		return true
 	}
 
 	closure :: proc(ok: bool) {
-		fmt.println("Goodbye?", ok);
+		fmt.println("Goodbye?", ok)
 	}
 
 	if open("Welcome") {
-		fmt.println("Something in the middle, mate.");
+		fmt.println("Something in the middle, mate.")
 	}
 }
 
 reflection :: proc() {
-	fmt.println("\n# reflection");
+	fmt.println("\n# reflection")
 
 	Foo :: struct {
 		x: int    `tag1`,
 		y: string `json:"y_field"`,
 		z: bool, // no tag
-	};
+	}
 
-	id := typeid_of(Foo);
-	names := reflect.struct_field_names(id);
-	types := reflect.struct_field_types(id);
-	tags  := reflect.struct_field_tags(id);
+	id := typeid_of(Foo)
+	names := reflect.struct_field_names(id)
+	types := reflect.struct_field_types(id)
+	tags  := reflect.struct_field_tags(id)
 
-	assert(len(names) == len(types) && len(names) == len(tags));
+	assert(len(names) == len(types) && len(names) == len(tags))
 
-	fmt.println("Foo :: struct {");
+	fmt.println("Foo :: struct {")
 	for tag, i in tags {
-		name, type := names[i], types[i];
+		name, type := names[i], types[i]
 		if tag != "" {
-			fmt.printf("\t%s: %T `%s`,\n", name, type, tag);
+			fmt.printf("\t%s: %T `%s`,\n", name, type, tag)
 		} else {
-			fmt.printf("\t%s: %T,\n", name, type);
+			fmt.printf("\t%s: %T,\n", name, type)
 		}
 	}
-	fmt.println("}");
+	fmt.println("}")
 
 
 	for tag, i in tags {
 		if val, ok := reflect.struct_tag_lookup(tag, "json"); ok {
-			fmt.printf("json: %s -> %s\n", names[i], val);
+			fmt.printf("json: %s -> %s\n", names[i], val)
 		}
 	}
 }
 
 quaternions :: proc() {
 	// Not just an April Fool's Joke any more, but a fully working thing!
-	fmt.println("\n# quaternions");
+	fmt.println("\n# quaternions")
 
 	{ // Quaternion operations
-		q := 1 + 2i + 3j + 4k;
-		r := quaternion(5, 6, 7, 8);
-		t := q * r;
-		fmt.printf("(%v) * (%v) = %v\n", q, r, t);
-		v := q / r;
-		fmt.printf("(%v) / (%v) = %v\n", q, r, v);
-		u := q + r;
-		fmt.printf("(%v) + (%v) = %v\n", q, r, u);
-		s := q - r;
-		fmt.printf("(%v) - (%v) = %v\n", q, r, s);
+		q := 1 + 2i + 3j + 4k
+		r := quaternion(5, 6, 7, 8)
+		t := q * r
+		fmt.printf("(%v) * (%v) = %v\n", q, r, t)
+		v := q / r
+		fmt.printf("(%v) / (%v) = %v\n", q, r, v)
+		u := q + r
+		fmt.printf("(%v) + (%v) = %v\n", q, r, u)
+		s := q - r
+		fmt.printf("(%v) - (%v) = %v\n", q, r, s)
 	}
 	{ // The quaternion types
-		q128: quaternion128; // 4xf32
-		q256: quaternion256; // 4xf64
-		q128 = quaternion(1, 0, 0, 0);
-		q256 = 1; // quaternion(1, 0, 0, 0);
+		q128: quaternion128 // 4xf32
+		q256: quaternion256 // 4xf64
+		q128 = quaternion(1, 0, 0, 0)
+		q256 = 1 // quaternion(1, 0, 0, 0);
 	}
 	{ // Built-in procedures
-		q := 1 + 2i + 3j + 4k;
-		fmt.println("q =", q);
-		fmt.println("real(q) =", real(q));
-		fmt.println("imag(q) =", imag(q));
-		fmt.println("jmag(q) =", jmag(q));
-		fmt.println("kmag(q) =", kmag(q));
-		fmt.println("conj(q) =", conj(q));
-		fmt.println("abs(q)  =", abs(q));
+		q := 1 + 2i + 3j + 4k
+		fmt.println("q =", q)
+		fmt.println("real(q) =", real(q))
+		fmt.println("imag(q) =", imag(q))
+		fmt.println("jmag(q) =", jmag(q))
+		fmt.println("kmag(q) =", kmag(q))
+		fmt.println("conj(q) =", conj(q))
+		fmt.println("abs(q)  =", abs(q))
 	}
 	{ // Conversion of a complex type to a quaternion type
-		c := 1 + 2i;
-		q := quaternion256(c);
-		fmt.println(c);
-		fmt.println(q);
+		c := 1 + 2i
+		q := quaternion256(c)
+		fmt.println(c)
+		fmt.println(q)
 	}
 	{ // Memory layout of Quaternions
-		q := 1 + 2i + 3j + 4k;
-		a := transmute([4]f64)q;
-		fmt.println("Quaternion memory layout: xyzw/(ijkr)");
-		fmt.println(q); // 1.000+2.000i+3.000j+4.000k
-		fmt.println(a); // [2.000, 3.000, 4.000, 1.000]
+		q := 1 + 2i + 3j + 4k
+		a := transmute([4]f64)q
+		fmt.println("Quaternion memory layout: xyzw/(ijkr)")
+		fmt.println(q) // 1.000+2.000i+3.000j+4.000k
+		fmt.println(a) // [2.000, 3.000, 4.000, 1.000]
 	}
 }
 
 unroll_for_statement :: proc() {
-	fmt.println("\n#'#unroll for' statements");
+	fmt.println("\n#'#unroll for' statements")
 
 	// '#unroll for' works the same as if the 'inline' prefix did not
 	// exist but these ranged loops are explicitly unrolled which can
 	// be very very useful for certain optimizations
 
-	fmt.println("Ranges");
+	fmt.println("Ranges")
 	#unroll for x, i in 1..<4 {
-		fmt.println(x, i);
+		fmt.println(x, i)
 	}
 
-	fmt.println("Strings");
+	fmt.println("Strings")
 	#unroll for r, i in "Hello, 世界" {
-		fmt.println(r, i);
+		fmt.println(r, i)
 	}
 
-	fmt.println("Arrays");
+	fmt.println("Arrays")
 	#unroll for elem, idx in ([4]int{1, 4, 9, 16}) {
-		fmt.println(elem, idx);
+		fmt.println(elem, idx)
 	}
 
 
@@ -1521,43 +1521,43 @@ unroll_for_statement :: proc() {
 		B,
 		C = 6,
 		D,
-	};
-	fmt.println("Enum types");
+	}
+	fmt.println("Enum types")
 	#unroll for elem, idx in Foo_Enum {
-		fmt.println(elem, idx);
+		fmt.println(elem, idx)
 	}
 }
 
 where_clauses :: proc() {
-	fmt.println("\n#procedure 'where' clauses");
+	fmt.println("\n#procedure 'where' clauses")
 
 	{ // Sanity checks
 		simple_sanity_check :: proc(x: [2]int)
 			where len(x) > 1,
 				  type_of(x) == [2]int {
-			fmt.println(x);
+			fmt.println(x)
 		}
 	}
 	{ // Parametric polymorphism checks
 		cross_2d :: proc(a, b: $T/[2]$E) -> E
 			where intrinsics.type_is_numeric(E) {
-			return a.x*b.y - a.y*b.x;
+			return a.x*b.y - a.y*b.x
 		}
 		cross_3d :: proc(a, b: $T/[3]$E) -> T
 			where intrinsics.type_is_numeric(E) {
-			x := a.y*b.z - a.z*b.y;
-			y := a.z*b.x - a.x*b.z;
-			z := a.x*b.y - a.y*b.z;
-			return T{x, y, z};
+			x := a.y*b.z - a.z*b.y
+			y := a.z*b.x - a.x*b.z
+			z := a.x*b.y - a.y*b.z
+			return T{x, y, z}
 		}
 
-		a := [2]int{1, 2};
-		b := [2]int{5, -3};
-		fmt.println(cross_2d(a, b));
+		a := [2]int{1, 2}
+		b := [2]int{5, -3}
+		fmt.println(cross_2d(a, b))
 
-		x := [3]f32{1, 4, 9};
-		y := [3]f32{-5, 0, 3};
-		fmt.println(cross_3d(x, y));
+		x := [3]f32{1, 4, 9}
+		y := [3]f32{-5, 0, 3}
+		fmt.println(cross_3d(x, y))
 
 		// Failure case
 		// i := [2]bool{true, false};
@@ -1569,25 +1569,25 @@ where_clauses :: proc() {
 	{ // Procedure groups usage
 		foo :: proc(x: [$N]int) -> bool
 			where N > 2 {
-			fmt.println(#procedure, "was called with the parameter", x);
-			return true;
+			fmt.println(#procedure, "was called with the parameter", x)
+			return true
 		}
 
 		bar :: proc(x: [$N]int) -> bool
 			where 0 < N,
 				  N <= 2 {
-			fmt.println(#procedure, "was called with the parameter", x);
-			return false;
+			fmt.println(#procedure, "was called with the parameter", x)
+			return false
 		}
 
-		baz :: proc{foo, bar};
+		baz :: proc{foo, bar}
 
-		x := [3]int{1, 2, 3};
-		y := [2]int{4, 9};
-		ok_x := baz(x);
-		ok_y := baz(y);
-		assert(ok_x == true);
-		assert(ok_y == false);
+		x := [3]int{1, 2, 3}
+		y := [2]int{4, 9}
+		ok_x := baz(x)
+		ok_y := baz(y)
+		assert(ok_x == true)
+		assert(ok_y == false)
 	}
 
 	{ // Record types
@@ -1596,11 +1596,11 @@ where_clauses :: proc() {
 				  N > 2 {
 			x: [N]T,
 			y: [N-2]T,
-		};
+		}
 
-		T :: i32;
-		N :: 5;
-		f: Foo(T, N);
+		T :: i32
+		N :: 5
+		f: Foo(T, N)
 		#assert(size_of(f) == (N+N-2)*size_of(T));
 	}
 }
@@ -1611,7 +1611,7 @@ when ODIN_OS == "windows" {
 }
 
 foreign_system :: proc() {
-	fmt.println("\n#foreign system");
+	fmt.println("\n#foreign system")
 	when ODIN_OS == "windows" {
 		// It is sometimes necessarily to interface with foreign code,
 		// such as a C library. In Odin, this is achieved through the
@@ -1650,10 +1650,10 @@ foreign_system :: proc() {
 }
 
 ranged_fields_for_array_compound_literals :: proc() {
-	fmt.println("\n#ranged fields for array compound literals");
+	fmt.println("\n#ranged fields for array compound literals")
 	{ // Normal Array Literal
-		foo := [?]int{1, 4, 9, 16};
-		fmt.println(foo);
+		foo := [?]int{1, 4, 9, 16}
+		fmt.println(foo)
 	}
 	{ // Indexed
 		foo := [?]int{
@@ -1661,46 +1661,46 @@ ranged_fields_for_array_compound_literals :: proc() {
 			1 = 4,
 			2 = 9,
 			0 = 1,
-		};
-		fmt.println(foo);
+		}
+		fmt.println(foo)
 	}
 	{ // Ranges
-		i := 2;
+		i := 2
 		foo := [?]int {
 			0 = 123,
 			5..=9 = 54,
 			10..<16 = i*3 + (i-1)*2,
-		};
+		}
 		#assert(len(foo) == 16);
-		fmt.println(foo); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
+		fmt.println(foo) // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
 	}
 	{ // Slice and Dynamic Array support
-		i := 2;
+		i := 2
 		foo_slice := []int {
 			0 = 123,
 			5..=9 = 54,
 			10..<16 = i*3 + (i-1)*2,
-		};
-		assert(len(foo_slice) == 16);
-		fmt.println(foo_slice); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
+		}
+		assert(len(foo_slice) == 16)
+		fmt.println(foo_slice) // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
 
 		foo_dynamic_array := [dynamic]int {
 			0 = 123,
 			5..=9 = 54,
 			10..<16 = i*3 + (i-1)*2,
-		};
-		assert(len(foo_dynamic_array) == 16);
-		fmt.println(foo_dynamic_array); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
+		}
+		assert(len(foo_dynamic_array) == 16)
+		fmt.println(foo_dynamic_array) // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
 	}
 }
 
 deprecated_attribute :: proc() {
 	@(deprecated="Use foo_v2 instead")
 	foo_v1 :: proc(x: int) {
-		fmt.println("foo_v1");
+		fmt.println("foo_v1")
 	}
 	foo_v2 :: proc(x: int) {
-		fmt.println("foo_v2");
+		fmt.println("foo_v2")
 	}
 
 	// NOTE: Uncomment to see the warning messages
@@ -1709,326 +1709,326 @@ deprecated_attribute :: proc() {
 
 range_statements_with_multiple_return_values :: proc() {
 	// IMPORTANT NOTE(bill, 2019-11-02): This feature is subject to be changed/removed
-	fmt.println("\n#range statements with multiple return values");
+	fmt.println("\n#range statements with multiple return values")
 	My_Iterator :: struct {
 		index: int,
 		data:  []i32,
-	};
+	}
 	make_my_iterator :: proc(data: []i32) -> My_Iterator {
-		return My_Iterator{data = data};
+		return My_Iterator{data = data}
 	}
 	my_iterator :: proc(it: ^My_Iterator) -> (val: i32, idx: int, cond: bool) {
 		if cond = it.index < len(it.data); cond {
-			val = it.data[it.index];
-			idx = it.index;
-			it.index += 1;
+			val = it.data[it.index]
+			idx = it.index
+			it.index += 1
 		}
-		return;
+		return
 	}
 
-	data := make([]i32, 6);
+	data := make([]i32, 6)
 	for _, i in data {
-		data[i] = i32(i*i);
+		data[i] = i32(i*i)
 	}
 
 	{
-		it := make_my_iterator(data);
+		it := make_my_iterator(data)
 		for val in my_iterator(&it) {
-			fmt.println(val);
+			fmt.println(val)
 		}
 	}
 	{
-		it := make_my_iterator(data);
+		it := make_my_iterator(data)
 		for val, idx in my_iterator(&it) {
-			fmt.println(val, idx);
+			fmt.println(val, idx)
 		}
 	}
 	{
-		it := make_my_iterator(data);
+		it := make_my_iterator(data)
 		for {
-			val, _, cond := my_iterator(&it);
+			val, _, cond := my_iterator(&it)
 			if !cond {
-				break;
+				break
 			}
-			fmt.println(val);
+			fmt.println(val)
 		}
 	}
 }
 
 
 soa_struct_layout :: proc() {
-	fmt.println("\n#SOA Struct Layout");
+	fmt.println("\n#SOA Struct Layout")
 
 	{
-		Vector3 :: struct {x, y, z: f32};
+		Vector3 :: struct {x, y, z: f32}
 
-		N :: 2;
-		v_aos: [N]Vector3;
-		v_aos[0].x = 1;
-		v_aos[0].y = 4;
-		v_aos[0].z = 9;
+		N :: 2
+		v_aos: [N]Vector3
+		v_aos[0].x = 1
+		v_aos[0].y = 4
+		v_aos[0].z = 9
 
-		fmt.println(len(v_aos));
-		fmt.println(v_aos[0]);
-		fmt.println(v_aos[0].x);
-		fmt.println(&v_aos[0].x);
+		fmt.println(len(v_aos))
+		fmt.println(v_aos[0])
+		fmt.println(v_aos[0].x)
+		fmt.println(&v_aos[0].x)
 
-		v_aos[1] = {0, 3, 4};
-		v_aos[1].x = 2;
-		fmt.println(v_aos[1]);
-		fmt.println(v_aos);
+		v_aos[1] = {0, 3, 4}
+		v_aos[1].x = 2
+		fmt.println(v_aos[1])
+		fmt.println(v_aos)
 
-		v_soa: #soa[N]Vector3;
+		v_soa: #soa[N]Vector3
 
-		v_soa[0].x = 1;
-		v_soa[0].y = 4;
-		v_soa[0].z = 9;
+		v_soa[0].x = 1
+		v_soa[0].y = 4
+		v_soa[0].z = 9
 
 
 		// Same syntax as AOS and treat as if it was an array
-		fmt.println(len(v_soa));
-		fmt.println(v_soa[0]);
-		fmt.println(v_soa[0].x);
-		fmt.println(&v_soa[0].x);
-		v_soa[1] = {0, 3, 4};
-		v_soa[1].x = 2;
-		fmt.println(v_soa[1]);
+		fmt.println(len(v_soa))
+		fmt.println(v_soa[0])
+		fmt.println(v_soa[0].x)
+		fmt.println(&v_soa[0].x)
+		v_soa[1] = {0, 3, 4}
+		v_soa[1].x = 2
+		fmt.println(v_soa[1])
 
 		// Can use SOA syntax if necessary
-		v_soa.x[0] = 1;
-		v_soa.y[0] = 4;
-		v_soa.z[0] = 9;
-		fmt.println(v_soa.x[0]);
+		v_soa.x[0] = 1
+		v_soa.y[0] = 4
+		v_soa.z[0] = 9
+		fmt.println(v_soa.x[0])
 
 		// Same pointer addresses with both syntaxes
-		assert(&v_soa[0].x == &v_soa.x[0]);
+		assert(&v_soa[0].x == &v_soa.x[0])
 
 
 		// Same fmt printing
-		fmt.println(v_aos);
-		fmt.println(v_soa);
+		fmt.println(v_aos)
+		fmt.println(v_soa)
 	}
 	{
 		// Works with arrays of length <= 4 which have the implicit fields xyzw/rgba
-		Vector3 :: distinct [3]f32;
+		Vector3 :: distinct [3]f32
 
-		N :: 2;
-		v_aos: [N]Vector3;
-		v_aos[0].x = 1;
-		v_aos[0].y = 4;
-		v_aos[0].z = 9;
+		N :: 2
+		v_aos: [N]Vector3
+		v_aos[0].x = 1
+		v_aos[0].y = 4
+		v_aos[0].z = 9
 
-		v_soa: #soa[N]Vector3;
+		v_soa: #soa[N]Vector3
 
-		v_soa[0].x = 1;
-		v_soa[0].y = 4;
-		v_soa[0].z = 9;
+		v_soa[0].x = 1
+		v_soa[0].y = 4
+		v_soa[0].z = 9
 	}
 	{
 		// SOA Slices
 		// Vector3 :: struct {x, y, z: f32};
-		Vector3 :: struct {x: i8, y: i16, z: f32};
+		Vector3 :: struct {x: i8, y: i16, z: f32}
 
-		N :: 3;
-		v: #soa[N]Vector3;
-		v[0].x = 1;
-		v[0].y = 4;
-		v[0].z = 9;
+		N :: 3
+		v: #soa[N]Vector3
+		v[0].x = 1
+		v[0].y = 4
+		v[0].z = 9
 
-		s: #soa[]Vector3;
-		s = v[:];
-		assert(len(s) == N);
-		fmt.println(s);
-		fmt.println(s[0].x);
+		s: #soa[]Vector3
+		s = v[:]
+		assert(len(s) == N)
+		fmt.println(s)
+		fmt.println(s[0].x)
 
-		a := s[1:2];
-		assert(len(a) == 1);
-		fmt.println(a);
+		a := s[1:2]
+		assert(len(a) == 1)
+		fmt.println(a)
 
-		d: #soa[dynamic]Vector3;
+		d: #soa[dynamic]Vector3
 
-		append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3});
-		fmt.println(d);
-		fmt.println(len(d));
-		fmt.println(cap(d));
-		fmt.println(d[:]);
+		append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3})
+		fmt.println(d)
+		fmt.println(len(d))
+		fmt.println(cap(d))
+		fmt.println(d[:])
 	}
 	{ // soa_zip and soa_unzip
-		fmt.println("\nsoa_zip and soa_unzip");
+		fmt.println("\nsoa_zip and soa_unzip")
 
-		x := []i32{1, 3, 9};
-		y := []f32{2, 4, 16};
-		z := []b32{true, false, true};
+		x := []i32{1, 3, 9}
+		y := []f32{2, 4, 16}
+		z := []b32{true, false, true}
 
 		// produce an #soa slice the normal slices passed
-		s := soa_zip(a=x, b=y, c=z);
+		s := soa_zip(a=x, b=y, c=z)
 
 		// iterate over the #soa slice
 		for v, i in s {
-			fmt.println(v, i); // exactly the same as s[i]
+			fmt.println(v, i) // exactly the same as s[i]
 			// NOTE: 'v' is NOT a temporary value but has a specialized addressing mode
 			// which means that when accessing v.a etc, it does the correct transformation
 			// internally:
 			//         s[i].a === s.a[i]
-			fmt.println(v.a, v.b, v.c);
+			fmt.println(v.a, v.b, v.c)
 		}
 
 		// Recover the slices from the #soa slice
-		a, b, c := soa_unzip(s);
-		fmt.println(a, b, c);
+		a, b, c := soa_unzip(s)
+		fmt.println(a, b, c)
 	}
 }
 
 constant_literal_expressions :: proc() {
-	fmt.println("\n#constant literal expressions");
+	fmt.println("\n#constant literal expressions")
 
-	Bar :: struct {x, y: f32};
-	Foo :: struct {a, b: int, using c: Bar};
+	Bar :: struct {x, y: f32}
+	Foo :: struct {a, b: int, using c: Bar}
 
-	FOO_CONST :: Foo{b = 2, a = 1, c = {3, 4}};
+	FOO_CONST :: Foo{b = 2, a = 1, c = {3, 4}}
 
 
-	fmt.println(FOO_CONST.a);
-	fmt.println(FOO_CONST.b);
-	fmt.println(FOO_CONST.c);
-	fmt.println(FOO_CONST.c.x);
-	fmt.println(FOO_CONST.c.y);
-	fmt.println(FOO_CONST.x); // using works as expected
-	fmt.println(FOO_CONST.y);
+	fmt.println(FOO_CONST.a)
+	fmt.println(FOO_CONST.b)
+	fmt.println(FOO_CONST.c)
+	fmt.println(FOO_CONST.c.x)
+	fmt.println(FOO_CONST.c.y)
+	fmt.println(FOO_CONST.x) // using works as expected
+	fmt.println(FOO_CONST.y)
 
-	fmt.println("-------");
+	fmt.println("-------")
 
-	ARRAY_CONST :: [3]int{1 = 4, 2 = 9, 0 = 1};
+	ARRAY_CONST :: [3]int{1 = 4, 2 = 9, 0 = 1}
 
-	fmt.println(ARRAY_CONST[0]);
-	fmt.println(ARRAY_CONST[1]);
-	fmt.println(ARRAY_CONST[2]);
+	fmt.println(ARRAY_CONST[0])
+	fmt.println(ARRAY_CONST[1])
+	fmt.println(ARRAY_CONST[2])
 
-	fmt.println("-------");
+	fmt.println("-------")
 
-	FOO_ARRAY_DEFAULTS :: [3]Foo{{}, {}, {}};
-	fmt.println(FOO_ARRAY_DEFAULTS[2].x);
+	FOO_ARRAY_DEFAULTS :: [3]Foo{{}, {}, {}}
+	fmt.println(FOO_ARRAY_DEFAULTS[2].x)
 
-	fmt.println("-------");
+	fmt.println("-------")
 
-	Baz :: enum{A=5, B, C, D};
-	ENUM_ARRAY_CONST :: [Baz]int{.A ..= .C = 1, .D = 16};
+	Baz :: enum{A=5, B, C, D}
+	ENUM_ARRAY_CONST :: [Baz]int{.A ..= .C = 1, .D = 16}
 
-	fmt.println(ENUM_ARRAY_CONST[.A]);
-	fmt.println(ENUM_ARRAY_CONST[.B]);
-	fmt.println(ENUM_ARRAY_CONST[.C]);
-	fmt.println(ENUM_ARRAY_CONST[.D]);
+	fmt.println(ENUM_ARRAY_CONST[.A])
+	fmt.println(ENUM_ARRAY_CONST[.B])
+	fmt.println(ENUM_ARRAY_CONST[.C])
+	fmt.println(ENUM_ARRAY_CONST[.D])
 
-	fmt.println("-------");
+	fmt.println("-------")
 
-	Partial_Baz :: enum{A=5, B, C, D=16};
+	Partial_Baz :: enum{A=5, B, C, D=16}
 	#assert(len(Partial_Baz) < len(#partial [Partial_Baz]int));
-	PARTIAL_ENUM_ARRAY_CONST :: #partial [Partial_Baz]int{.A ..= .C = 1, .D = 16};
+	PARTIAL_ENUM_ARRAY_CONST :: #partial [Partial_Baz]int{.A ..= .C = 1, .D = 16}
 
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.A]);
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.B]);
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.C]);
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.D]);
+	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.A])
+	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.B])
+	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.C])
+	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.D])
 
-	fmt.println("-------");
+	fmt.println("-------")
 
 
-	STRING_CONST :: "Hellope!";
+	STRING_CONST :: "Hellope!"
 
-	fmt.println(STRING_CONST[0]);
-	fmt.println(STRING_CONST[2]);
-	fmt.println(STRING_CONST[3]);
+	fmt.println(STRING_CONST[0])
+	fmt.println(STRING_CONST[2])
+	fmt.println(STRING_CONST[3])
 
-	fmt.println(STRING_CONST[0:5]);
-	fmt.println(STRING_CONST[3:][:4]);
+	fmt.println(STRING_CONST[0:5])
+	fmt.println(STRING_CONST[3:][:4])
 }
 
 union_maybe :: proc() {
-	fmt.println("\n#union #maybe");
+	fmt.println("\n#union #maybe")
 
 	// NOTE: This is already built-in, and this is just a reimplementation to explain the behaviour
-	Maybe :: union($T: typeid) #maybe {T};
+	Maybe :: union($T: typeid) #maybe {T}
 
-	i: Maybe(u8);
-	p: Maybe(^u8); // No tag is stored for pointers, nil is the sentinel value
+	i: Maybe(u8)
+	p: Maybe(^u8) // No tag is stored for pointers, nil is the sentinel value
 
 	#assert(size_of(i) == size_of(u8) + size_of(u8));
 	#assert(size_of(p) == size_of(^u8));
 
-	i = 123;
-	x := i.?;
-	y, y_ok := p.?;
-	p = &x;
-	z, z_ok := p.?;
+	i = 123
+	x := i.?
+	y, y_ok := p.?
+	p = &x
+	z, z_ok := p.?
 
-	fmt.println(i, p);
-	fmt.println(x, &x);
-	fmt.println(y, y_ok);
-	fmt.println(z, z_ok);
+	fmt.println(i, p)
+	fmt.println(x, &x)
+	fmt.println(y, y_ok)
+	fmt.println(z, z_ok)
 }
 
 dummy_procedure :: proc() {
-	fmt.println("dummy_procedure");
+	fmt.println("dummy_procedure")
 }
 
 explicit_context_definition :: proc "c" () {
 	// Try commenting the following statement out below
-	context = runtime.default_context();
+	context = runtime.default_context()
 
-	fmt.println("\n#explicit context definition");
-	dummy_procedure();
+	fmt.println("\n#explicit context definition")
+	dummy_procedure()
 }
 
 relative_data_types :: proc() {
-	fmt.println("\n#relative data types");
-
-	x: int = 123;
-	ptr: #relative(i16) ^int;
-	ptr = &x;
-	fmt.println(ptr^);
-
-	arr := [3]int{1, 2, 3};
-	s := arr[:];
-	rel_slice: #relative(i16) []int;
-	rel_slice = s;
-	fmt.println(rel_slice);
-	fmt.println(rel_slice[:]);
-	fmt.println(rel_slice[1]);
+	fmt.println("\n#relative data types")
+
+	x: int = 123
+	ptr: #relative(i16) ^int
+	ptr = &x
+	fmt.println(ptr^)
+
+	arr := [3]int{1, 2, 3}
+	s := arr[:]
+	rel_slice: #relative(i16) []int
+	rel_slice = s
+	fmt.println(rel_slice)
+	fmt.println(rel_slice[:])
+	fmt.println(rel_slice[1])
 }
 
 or_else_operator :: proc() {
-	fmt.println("\n#'or_else'");
+	fmt.println("\n#'or_else'")
 	// IMPORTANT NOTE: 'or_else' is an experimental feature and subject to change/removal
 	{
-		m: map[string]int;
-		i: int;
-		ok: bool;
+		m: map[string]int
+		i: int
+		ok: bool
 
 		if i, ok = m["hellope"]; !ok {
-			i = 123;
+			i = 123
 		}
 		// The above can be mapped to 'or_else'
-		i = m["hellope"] or_else 123;
+		i = m["hellope"] or_else 123
 
-		assert(i == 123);
+		assert(i == 123)
 	}
 	{
 		// 'or_else' can be used with type assertions too, as they
 		// have optional ok semantics
-		v: union{int, f64};
-		i: int;
-		i = v.(int) or_else  123;
-		i = v.? or_else 123; // Type inference magic
-		assert(i == 123);
+		v: union{int, f64}
+		i: int
+		i = v.(int) or_else  123
+		i = v.? or_else 123 // Type inference magic
+		assert(i == 123)
 
-		m: Maybe(int);
-		i = m.? or_else 456;
-		assert(i == 456);
+		m: Maybe(int)
+		i = m.? or_else 456
+		assert(i == 456)
 	}
 }
 
 or_return_operator :: proc() {
-	fmt.println("\n#'or_return'");
+	fmt.println("\n#'or_return'")
 	// IMPORTANT NOTE: 'or_return' is an experimental feature and subject to change/removal
 	//
 	// The concept of 'or_return' will work by popping off the end value in a multiple
@@ -2044,42 +2044,42 @@ or_return_operator :: proc() {
 		Something_Worse,
 		The_Worst,
 		Your_Mum,
-	};
+	}
 
 	caller_1 :: proc() -> Error {
-		return .None;
+		return .None
 	}
 
 	caller_2 :: proc() -> (int, Error) {
-		return 123, .None;
+		return 123, .None
 	}
 	caller_3 :: proc() -> (int, int, Error) {
-		return 123, 345, .None;
+		return 123, 345, .None
 	}
 
 	foo_1 :: proc() -> Error {
 		// This can be a common idiom in many code bases
-		n0, err := caller_2();
+		n0, err := caller_2()
 		if err != nil {
-			return err;
+			return err
 		}
 
 		// The above idiom can be transformed into the following
-		n1 := caller_2() or_return;
+		n1 := caller_2() or_return
 
 
 		// And if the expression is 1-valued, it can be used like this
-		caller_1() or_return;
+		caller_1() or_return
 		// which is functionally equivalent to
 		if err1 := caller_1(); err1 != nil {
-			return err1;
+			return err1
 		}
 
 		// Multiple return values still work with 'or_return' as it only
 		// pops off the end value in the multi-valued expression
-		n0, n1 = caller_3() or_return;
+		n0, n1 = caller_3() or_return
 
-		return .None;
+		return .None
 	}
 	foo_2 :: proc() -> (n: int, err: Error) {
 		// It is more common that your procedure turns multiple values
@@ -2088,79 +2088,79 @@ or_return_operator :: proc() {
 		// so that a bare 'return' statement can be used
 
 		// This can be a common idiom in many code bases
-		x: int;
-		x, err = caller_2();
+		x: int
+		x, err = caller_2()
 		if err != nil {
-			return;
+			return
 		}
 
 		// The above idiom can be transformed into the following
-		y := caller_2() or_return;
-		_ = y;
+		y := caller_2() or_return
+		_ = y
 
 		// And if the expression is 1-valued, it can be used like this
-		caller_1() or_return;
+		caller_1() or_return
 
 		// which is functionally equivalent to
 		if err1 := caller_1(); err1 != nil {
-			err = err1;
-			return;
+			err = err1
+			return
 		}
 
 		// If using a non-bare 'return' statement is required, setting the return values
 		// using the normal idiom is a better choice and clearer to read.
 		if z, zerr := caller_2(); zerr != nil {
-			return -345 * z, zerr;
+			return -345 * z, zerr
 		}
 
 		// If the other return values need to be set depending on what the end value is,
 		// the 'defer if' idiom is can be used
 		defer if err != nil {
-			n = -1;
+			n = -1
 		}
 
-		n = 123;
-		return;
+		n = 123
+		return
 	}
 
-	foo_1();
-	foo_2();
+	foo_1()
+	foo_2()
 }
 
 
 main :: proc() {
 	when true {
-		the_basics();
-		control_flow();
-		named_proc_return_parameters();
-		explicit_procedure_overloading();
-		struct_type();
-		union_type();
-		using_statement();
-		implicit_context_system();
-		parametric_polymorphism();
-		array_programming();
-		map_type();
-		implicit_selector_expression();
-		partial_switch();
-		cstring_example();
-		bit_set_type();
-		deferred_procedure_associations();
-		reflection();
-		quaternions();
-		unroll_for_statement();
-		where_clauses();
-		foreign_system();
-		ranged_fields_for_array_compound_literals();
-		deprecated_attribute();
-		range_statements_with_multiple_return_values();
-		threading_example();
-		soa_struct_layout();
-		constant_literal_expressions();
-		union_maybe();
-		explicit_context_definition();
-		relative_data_types();
-		or_else_operator();
-		or_return_operator();
+		the_basics()
+		control_flow()
+		named_proc_return_parameters()
+		explicit_procedure_overloading()
+		struct_type()
+		union_type()
+		using_statement()
+		implicit_context_system()
+		parametric_polymorphism()
+		array_programming()
+		map_type()
+		implicit_selector_expression()
+		partial_switch()
+		cstring_example()
+		bit_set_type()
+		deferred_procedure_associations()
+		reflection()
+		quaternions()
+		unroll_for_statement()
+		where_clauses()
+		foreign_system()
+		ranged_fields_for_array_compound_literals()
+		deprecated_attribute()
+		range_statements_with_multiple_return_values()
+		threading_example()
+		soa_struct_layout()
+		constant_literal_expressions()
+		union_maybe()
+		explicit_context_definition()
+		relative_data_types()
+		or_else_operator()
+		or_return_operator()
 	}
 }