replace text buttons above code blocks with icons

Author: Book-reader

content/Basics/11-structs unions.md

@@ -10,5 +10,28 @@ weight: 11
 - Structs and unions can be nested.
 - Initialization follows C rules with `{ }`.
 - Unlike C it's possible to reassign the value of a struct or union with `{ }` as well.
-{{<end11>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+union Point
+{
+	// Nested struct
+	struct
+	{
+		int x, y;
+	}
+	int[2] v;
+}
+
+fn void main()
+{
+	Point p = { 2, 3 };
+
+	io::printfn("Point: %d, %d", p.x, p.y);
+	// Reassign the p value using a literal and named arguments:
+	p = { .v = { 5, -1 } };
+	io::printfn("Point: %d, %d", p.x, p.y);
+}
+{{</defcod>}}

content/Basics/13-slices.md

@@ -25,5 +25,16 @@ int[] foo8 = list[^2..]; // ^2 means "len - 2"
 int[] foo8 = list[^2..^1]; 
 int[] foo9 = list[^2:2];
 ```
-{{<end13>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn void main()
+{
+	int[6] list = { 2, 3, 5, 7, 11, 13 };
+	int[] s = list[1..4];
+
+	io::printfn("%s", s);
+}
+{{</defcod>}}

content/Basics/6-foreach.md

@@ -10,4 +10,27 @@ weight: 6
 - `foreach_r` conversely allows iteration from back and forward.
 - Either iterate over the value: `foreach (v : values)` or over index + value: `foreach (index, v : values)`
 - Values can also be retrieved by reference by using `&` in front of the variable name: `foreach (&v : values)`, this allows mutation of the element directly.
-{{<end6>}}
+{{<end>}}
+
+{{<defcod>}}
+import std::io;
+
+fn void test(float[] values)
+{
+	io::printn("Forward");
+	foreach (index, value : values)
+	{
+		io::printfn("%d: %f", index, value);
+	}
+	io::printn("Back");
+	foreach_r (index, value : values)
+	{
+		io::printfn("%d: %f", index, value);
+	}
+}
+
+fn void main()
+{
+	test({ 3.2, 5.0, 1.5, 7.135});
+}
+{{</defcod>}}

content/Basics/7-if.md

@@ -6,5 +6,26 @@ aliases:
 weight: 7
 ---
 {{<start>}}
-{{<end7>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn void main()
+{
+	int x = 2;
+
+	if (x == 1)
+	{
+		io::printfn("1");
+	}
+	else if (x == 2)
+	{
+		io::printfn("2");
+	}
+	else
+	{
+		io::printfn("0");
+	}
+}
+{{</defcod>}}

content/Basics/8-switch.md

@@ -7,5 +7,26 @@ weight: 8
 ---
 {{<start>}}
 - `case` statements automatically break.
-{{<end8>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+import std::core::env;
+
+fn void main()
+{
+	io::printf("It's crucial to say ");
+	switch (env::OS_TYPE)
+	{
+		case WIN32:
+			io::printf("WNU-");
+		case LINUX:
+			io::printf("GNU-");
+		case MACOS:
+			io::printf("MNU-");
+		default:
+			io::printf("DUNNO-");
+	}
+	io::printfn("Linux.");
+}
+{{</defcod>}}

content/Basics/9-nextcase.md

@@ -8,5 +8,29 @@ weight: 9
 {{<start>}}
 - Use `nextcase` to fallthrough to the next statement.
 - Empty case statements have implicit fallthrough.
-{{<end9>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn void main()
+{
+	String s = "Gone--";
+
+	switch (s)
+	{
+		case "Python":
+			io::printf("Far from ");
+			nextcase "C3";
+		case "OOP++":
+			io::printf("Definitely not ");
+			nextcase;
+		case "C3":
+		case "C":
+			io::printfn("OK");
+		default:
+			io::printf("Most likely not ");
+			nextcase "C3";
+	}
+}
+{{</defcod>}}

content/More/1-asm block.md

@@ -7,5 +7,21 @@ weight: 1
 ---
 {{<start>}}
 - Asm blocks uses a common grammar for all types of processors.
-{{<end14>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn void main()
+{
+	int x = 3;
+	
+	io::printfn("%d", x);
+	asm
+	{
+		xorl $eax,$eax;
+		movl x,$eax;
+	}
+	io::printfn("%d", x);
+}
+{{</defcod>}}

content/More/13-initializers finalizers.md

@@ -7,5 +7,23 @@ weight: 13
 ---
 {{<start>}}
 - It is sometimes useful to run code at startup and shutdown. Static initializers and finalizers are special functions that are run at startup and shutdown respectively.
-{{<end26>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn void hello() @init
+{
+	io::printf("hello");
+}
+
+fn void world() @finalizer
+{
+	io::printfn("world");
+}
+
+fn void main()
+{
+	io::printf(", ");
+}
+{{</defcod>}}

content/More/14-extended switch.md

@@ -7,5 +7,32 @@ weight: 14
 ---
 {{<start>}}
 - It's possible to have an extended `switch`, which can take any type of conditionals.
-{{<end27>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn bool is_odd(int x)
+{
+	return x % 2 == 1;
+}
+
+fn void main()
+{
+	int x = 2;
+
+	switch
+	{
+	case x == 1:
+		io::printfn("One");
+	case is_odd(x):
+		io::printfn("Odd");
+	case x < 0:
+		io::printfn("Negative");
+	case x == 0:
+		io::printfn("Zero");
+	default:
+		io::printfn("Number was: %d", x);
+	}
+}
+{{</defcod>}}

content/More/17-short function syntax.md

@@ -8,5 +8,16 @@ weight: 17
 {{<start>}}
 - Rather than using `{}` to define the function body, one can use `=> <expr>`.
 - This behaves as if the function only contained a single return, returning the expression.
-{{<end30>}}
+{{<end>}}
 
+{{<defcod>}}
+import std::io;
+
+fn int square(int x) => x * x;
+fn void printx(int x) => io::printfn("%d", x);
+
+fn void main()
+{
+	printx(square(3));
+}
+{{</defcod>}}