update to 0.8.0

Author: Book-reader

content/Basics/5-for.md

@@ -8,7 +8,7 @@ weight: 5
 C3 `for` loops are the same as in C.<br>
 A `for` loop is made of 3 sections that are enclosed in parentheses and separated by semicolons:
  - the init section, which is is run once when the loop is first started and
-   usually used to declare the counter (eg `usz i = 0`).
+   usually used to declare the counter (eg `sz i = 0`).
  - the condition section, which is checked before the code in the loop body is
    executed each iteration of the loop. The loop will continue running until the
    condition is no longer true.
@@ -26,7 +26,7 @@ import std::io;
 fn void main()
 {
 	const TIMES = 5;
-	for (usz i = 0; i < TIMES; i = i + 1)
+	for (sz i = 0; i < TIMES; i = i + 1)
 	{
 		io::printfn("Iteration %s", i);
 	}
@@ -41,7 +41,7 @@ import std::io;
 fn void main()
 {
 	const TIMES = 10;
-	for (usz i = 0; i < TIMES; i++)
+	for (sz i = 0; i < TIMES; i++)
 	{
 		if (i == 3)
 		{
@@ -65,7 +65,7 @@ array or hashmap with a `for` loop can become a bit cumbersome, this is where
 fn void main()
 {
 	int[3] items = {123, 456, 789};
-	for (usz i = 0; i < items.len; i++)
+	for (sz i = 0; i < items.len; i++)
 	{
 		items[i] += items[i];
 	}

content/More/15-distinct type type alias.md

@@ -9,21 +9,25 @@ weight: 15
 - Uses the uniform `alias` syntax.
 - Regular type aliases are the same as C `typedef`, C3 `typedef` creates a distinct type.
 - Distinct types are type aliases that doesn't implicitly convert to the aliased type.
-- `typedef inline` types can automatically convert to its underlying type and inherit the methods of its underlying type, but otherwise works as distinct types.
+- `typedef inline` types can automatically convert to their underlying type and inherit the methods of their underlying type, but otherwise work as distinct types.
+- By default constants of the underlying type have to be cast to a distinct type, but using the `@constinit` attribute will allow implicit conversion.
 {{<end>}}
 
 {{<defcod>}}
 import std::io;
 
 alias MyInt = int;
-typedef MyId = int;
+typedef MyId @constinit = int;
+typedef StrongId = int;
 
 fn void main()
 {
 	MyInt x = 27;
 	MyId y = 3;
 	int a = x;
-	// int b = y; <- This doesn't work
+	StrongId b = (StrongId)42; // An explicit cast is required
+
+	// int c = y; <- This doesn't work
 
 	// Explicit conversion works
 	x += (int)y;

content/More/19-examples.md

@@ -64,22 +64,22 @@ import std::io;
 
 fn void main()
 {
-	usz count = 5;
+	sz count = 5;
 	int starting_value = 0;
 	String res = some_func(mem, count, starting_value);
 	io::printn(res);
 	mem::free(res);
 }
 
-fn String some_func(Allocator alloc, usz count, int starting_value)
+fn String some_func(Allocator alloc, sz count, int starting_value)
 {
 	@pool()
 	{
 		DString buf;
 		// Initialise the string builder using the temporary allocator
 		// The `@pool()` ensures it will be automatically freed when the function exits
 		buf.init(tmem);
-		for (usz i = 0; i < count; i++) buf.appendf("[%s]", starting_value + i);
+		for (sz i = 0; i < count; i++) buf.appendf("[%s]", starting_value + i);
 		// Copy the final string into the passed allocator
 		return buf.copy_str(alloc);
 	};

content/More/6-reflection.md

@@ -7,17 +7,18 @@ weight: 6
 ---
 {{<start>}}
 - There are several built-in functions to inspect the code during compile time.
-- `.len` on arrays return their length.
+- `.len` on arrays and slices returns their length.
 - `$defined(<expr>)` returns true if the expression inside is defined.
-- `$alignof(<expr>)` returns alignment.
-- `$sizeof(<expr>)` returns size.
-- `$qnameof(<identifier>)` to get the qualified name of the identifier, e.g `std::io::printf`
-- `$nameof(<identifier>)` to get the base name of the identifier, e.g. `printf`
-- `$typeof(<expr>)` returns the type of the expression.
+- `$reflect(<identifier>)` returns a struct containing information about the identifier, often including the following properties:
+  - `.size`: the size of the value in bytes, the stdlib provides the `@sizeof(x)` macro as a shorthand for `$reflect(x).size`.
+  - `.alignment`: the alignment of the value in bytes, the stdlib provides `@alignof(x)` as a shorthand.
+  - `.qname`: the qualified name of the identifier, e.g `std::io::printf`. The stdlib provides `@qnameof(x)` as a shorthand.
+  - `.name`: the base name of the identifier, e.g. `printf`. The stdlib provides `@nameof(x)` as a shorthand.
+- `$Typeof(<expr>)` returns the type of the expression.
 - `$stringify(<expr>)` returns the expression as a string.
-- `<type>.sizeof` returns the size of a type.
-- `<type>.alignof` returns the alignment of a type.
-- `<type>.nameof` return the name of a type.
+- `<type>::size` returns the size of a type.
+- `<type>::align` returns the alignment of a type.
+- `<type>::name` return the name of a type.
 
 See https://c3-lang.org/generic-programming/reflection/ for the full details.
 {{<end>}}
@@ -34,8 +35,8 @@ fn void main()
 	{
 		io::printfn("hello, world");
 	}
-	io::printfn($qnameof(io::printfn));
-	io::printfn("%s %s", $sizeof(x), $sizeof(y));
-	io::printfn("isz has size: %d", isz.sizeof);
+	io::printfn($reflect(io::printfn).qname);
+	io::printfn("%s %s", $reflect(x).size, @sizeof(y));
+	io::printfn("sz has size: %d", sz::size);
 }
 {{</defcod>}}