Merge pull request #49 from pedropark99/slices

Add section for runtime versus compile-time known length in slices.

Author: pedropark99

Chapters/01-zig-weird.qmd

@@ -771,7 +771,7 @@ and the way in which arrays are expanded is tightly related to
 memory management.
 
 
-### Selecting elements of the array
+### Selecting elements of the array {#sec-select-array-elem}
 
 One very commom activity is to select specific portions of an array
 you have in your source code.
@@ -917,6 +917,75 @@ try stdout.print("{any}\n", .{c});
 ```
 
 
+### Runtime versus compile-time known length in slices
+
+We are going to talk a lot about the differences between compile-time known
+and runtime known across this book, specially at @sec-compile-time.
+But the basic idea is that a thing is compile-time known, when we know
+everything (the value, the attributes and the characteristics) about this thing at compile-time.
+In contrast, a runtime known thing is when the exact value of a thing is calculated only at runtime.
+Therefore, we don't know the value of this thing at compile-time, only at runtime.
+
+We have learned at @sec-select-array-elem that slices are created by using a *range selector*,
+which represents a range of indexes. When this "range of indexes" (i.e. the start and the end of this range)
+is known at compile-time, the slice object that get's created is actually, under the hood, just
+a single-item pointer to an array.
+
+You don't need to precisely understand what that means now. We are going to talk a lot about pointers
+at @sec-pointer. For now, just understand that, when the range of indexes is known at compile-time,
+the slice that get's created is just a pointer to an array, accompanied by a length value that
+tells the size of the slice.
+
+If you have a slice object like this, i.e. a slice that has a compile-time known range,
+you can use common pointer operations over this slice object. For example, you can 
+dereference the pointer of this slice, by using the `.*` method, like you would
+do on a normal pointer object.
+
+```{zig}
+#| eval: false
+const arr1 = [10]u64 {
+    1, 2, 3, 4, 5,
+    6, 7, 8, 9, 10
+};
+// This slice have a compile-time known range.
+// Because we know both the start and end of the range.
+const slice = arr1[1..4];
+```
+
+
+On the other hand, if the range of indexes is not known at compile time, then, the slice object
+that get's created is not a pointer anymore, and, thus, it does not support pointer operations.
+For example, maybe the start index is known at compile time, but the end index is not. In such
+case, the range of the slice becomes runtime known only.
+
+In the example below, the `slice` object have a runtime known range, because the end index of the range
+is not known at compile time. In other words, the size of the array at `buffer` is not known
+at compile time. When we execute this program, the size of the array might be 10, or, it might be 12
+depending on where we execute it. Therefore, we don't know at compile time if
+the slice object have a range of size 10, or, a range of size 12.
+
+```{zig}
+#| auto_main: false
+#| build_type: "run"
+const std = @import("std");
+const builtin = @import("builtin");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+    var n: usize = 0;
+    if (builtin.target.os.tag == .windows) {
+        n = 10;
+    } else {
+        n = 12;
+    }
+    const buffer = try allocator.alloc(u64, n);
+    const slice = buffer[0..];
+    _ = slice;
+}
+```
+
+
 ## Blocks and scopes {#sec-blocks}
 
 Blocks are created in Zig by a pair of curly braces. A block is just a group of