Introduction to Zig

https://pedropark99.github.io/zig-book/
Admin
A project-based introductory book teaching the Zig programming language through practical projects...
Tokens:111,767
Snippets:818
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Zig Server: Listen and Accept Connection

Source: https://pedropark99.github.io/zig-book/Chapters/04-http-server

Initializes a Zig server, makes it listen for incoming connections on a specified address, and accepts a single connection. This example demonstrates the basic setup but will terminate after the first connection. It requires the `server.zig` module and Zig's standard library.

```zig
const std = @import("std");
const Server = @import("server.zig").Server;

pub fn main() !void {
    var alloc = std.heap.GeneralPurposeAllocator(.{}){};
    const gpa = alloc.allocator();
    var threaded: std.Io.Threaded = .init(gpa);
    const io = threaded.io();
    defer threaded.deinit();

    const server = try Server.init(io);
    var listening = try server.listen();
    const connection = try listening.accept(io);
    defer connection.close(io);
}
```

--------------------------------

### Install Build Artifacts in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/07-build-system

Demonstrates how to use `b.installArtifact(exe)` to copy the built executable to the `zig-out` directory. This ensures that the compiled binary is not discarded after the build process.

```zig
const exe = b.addExecutable(.{
    .name = "hello",
    .root_module = b.createModule(.{
        .root_source_file = b.path("hello.zig"),
        .target = b.graph.host
    })
});

b.installArtifact(exe);
```

--------------------------------

### Example Relative Path in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

This code snippet demonstrates a typical relative path used to access a file within a project structure. Relative paths are resolved starting from the current working directory.

```text
ZigExamples/zig-basics/hello_world.zig
```

--------------------------------

### Build Zig Project using Zig CLI

Source: https://pedropark99.github.io/zig-book/Chapters/13-image-filter

This command initiates the build process for a Zig project configured with a `build.zig` file. Ensure that all necessary dependencies, such as `libspng`, are installed on the system before running this command.

```bash
zig build
```

--------------------------------

### Full Zig Singly Linked List Implementation Example

Source: https://pedropark99.github.io/zig-book/Chapters/09-data-structures

Combines node definition, list initialization, node creation, insertion, and printing the list length. This snippet provides a complete, runnable example of using a singly linked list in Zig.

```zig
const std = @import("std");

const NodeU32 = struct {
    data: u32,
    node: std.SinglyLinkedList.Node = .{}, 
};

var list: std.SinglyLinkedList = .{};
var one: NodeU32 = .{ .data = 1 };
var two: NodeU32 = .{ .data = 2 };
var three: NodeU32 = .{ .data = 3 };
var five: NodeU32 = .{ .data = 5 };

list.prepend(&two.node); // {2}
two.node.insertAfter(&five.node); // {2, 5}
two.node.insertAfter(&three.node); // {2, 3, 5}
list.prepend(&one.node); // {1, 2, 3, 5}

try std.io.getStdOut().writer().print("Number of nodes: {}\
", .{list.len()});
try std.io.getStdOut().writer().flush();
```

--------------------------------

### Zig: Compile-Time Block Execution for Fibonacci

Source: https://pedropark99.github.io/zig-book/Chapters/10-stack-project

Illustrates executing a block of code at compile-time in Zig using the 'comptime' keyword. This example calculates Fibonacci numbers within a 'comptime' block, ensuring the operations are performed during compilation.

```zig
const expect = @import("std").testing.expect;
fn fibonacci(index: u32) u32 {
    if (index < 2) return index;
    return fibonacci(index - 1) + fibonacci(index - 2);
}

test "fibonacci in a block" {
    const x = comptime blk: {
        const n1 = 5;
        const n2 = 2;
        const n3 = n1 + n2;
        try expect(fibonacci(n3) == 13);
        break :blk n3;
    };
    _ = x;
}
```

--------------------------------

### Set Build Mode to ReleaseSafe in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/07-build-system

Shows how to specify the build mode for a target object using the `optimize` option. This example sets the mode to `ReleaseSafe`, prioritizing safety over performance.

```zig
const exe = b.addExecutable(.{
    .name = "hello",
    .root_module = b.createModule(.{
        .root_source_file = b.path("hello.zig"),
        .target = b.graph.host,
        .optimize = .ReleaseSafe
    })
});
b.installArtifact(exe);
```

--------------------------------

### Quickly Initialize Single-Threaded IO Backend in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

Provides a simplified method to instantiate a `std.Io.Threaded` object using a single thread. This is useful for quick setup or when a multi-threaded IO backend is not necessary. The IO interface is then retrieved for use.

```zig
var threaded: std.Io.Threaded = .init_single_threaded;
const io = threaded.io();
_ = io;
```

--------------------------------

### Build and Run Unit Tests in Zig Project

Source: https://pedropark99.github.io/zig-book/Chapters/07-build-system

This snippet demonstrates how to declare a test target object using `addTest()` and install it as an artifact. It then sets up a run step to execute these tests via a custom build command.

```zig
const test_exe = b.addTest(.{
    .name = "unit_tests",
    .root_module = b.createModule(.{
        .root_source_file = b.path("src/main.zig"),
        .target = b.graph.host
    })
});

b.installArtifact(test_exe);
```

```zig
const run_arti = b.addRunArtifact(test_exe);
const run_step = b.step("tests", "Run unit tests");
run_step.dependOn(&run_arti.step);
```

--------------------------------

### Zig Base64 Lookup Table Usage Example

Source: https://pedropark99.github.io/zig-book/Chapters/01-base64

Demonstrates how to use the 'Base64' struct in Zig. It initializes a 'Base64' object and then uses the '_char_at' method to retrieve and print the character corresponding to index 28 from the lookup table.

```zig
const base64 = Base64.init();
try stdout.print(
    "Character at index 28: {c}
",
    .{base64._char_at(28)}
);
try stdout.flush();

```

--------------------------------

### ArenaAllocator with GeneralPurposeAllocator in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/01-memory

Shows how to use Zig's ArenaAllocator, which allows multiple memory allocations to be freed with a single call to `deinit()`. This example initializes an ArenaAllocator with a GeneralPurposeAllocator, demonstrating efficient memory management for multiple, temporary allocations.

```zig
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
var aa = std.heap.ArenaAllocator.init(gpa.allocator());
defer aa.deinit();
const allocator = aa.allocator();

const in1 = try allocator.alloc(u8, 5);
const in2 = try allocator.alloc(u8, 10);
const in3 = try allocator.alloc(u8, 15);
_ = in1; _ = in2; _ = in3;
```

--------------------------------

### Initialize and Use AutoHashMap in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/09-data-structures

Demonstrates initializing an AutoHashMap with default settings for u32 keys and u16 values, performing put, get, and remove operations, and printing the count of stored values. It utilizes GeneralPurposeAllocator for memory management.

```zig
const std = @import("std");
const AutoHashMap = std.hash_map.AutoHashMap;

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var hash_table = AutoHashMap(u32, u16).init(allocator);
    defer hash_table.deinit();

    try hash_table.put(54321, 89);
    try hash_table.put(50050, 55);
    try hash_table.put(57709, 41);
    std.debug.print(
        "N of values stored: {d}\n",
        .{hash_table.count()}
    );
    std.debug.print(
        "Value at key 50050: {d}\n",
        .{hash_table.get(50050).?}
    );

    if (hash_table.remove(57709)) {
        std.debug.print(
            "Value at key 57709 successfully removed!\n",
            .{} 
        );
    }
    std.debug.print(
        "N of values stored: {d}\n",
        .{hash_table.count()}
    );
}
```

--------------------------------

### Execute Custom Build Step in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/07-build-system

Demonstrates how to view and execute custom build steps defined in a Zig build script. The `zig build --help` command lists available steps, and `zig build <step_name>` executes a specific step.

```bash
zig build --help
```

```bash
zig build run
```

--------------------------------

### HTTP Request Top-Level Header Example

Source: https://pedropark99.github.io/zig-book/Chapters/04-http-server

Shows a typical first line of an HTTP request, known as the top-level header. This line contains the HTTP method (e.g., GET), the requested URI (e.g., /users/list), and the HTTP protocol version (e.g., HTTP/1.1). This format is fundamental for servers to understand and process incoming client requests.

```http
GET /users/list HTTP/1.1
```

--------------------------------

### Create Zig Array Slices using Range Selectors (Exclusive End)

Source: https://pedropark99.github.io/zig-book/Chapters/01-zig-weird

Illustrates creating slices (sub-arrays) from a Zig array using the `start..end` range selector. The 'end' index is non-inclusive, meaning the element at the 'end' index itself is not included in the slice. This example selects elements from index 1 up to (but not including) index 3.

```zig
const ns = [4]u8{48, 24, 12, 6};
const sl = ns[1..3];
_ = sl;
```

--------------------------------

### Create Zig Array Slice to the End

Source: https://pedropark99.github.io/zig-book/Chapters/01-zig-weird

Explains how to create a slice from a specific starting index to the end of the Zig array. The syntax `start..` selects all elements from the `start` index onwards, including the last element.

```zig
const ns = [4]u8{48, 24, 12, 6};
const sl = ns[1..];
_ = sl;
```

--------------------------------

### Zig: Importing Modules and Defining Functions in root.zig

Source: https://pedropark99.github.io/zig-book/Chapters/01-zig-weird

Demonstrates how to import the standard library using `@import('std')`, define a public function `bufferedPrint` for buffered output to stdout, and a simple `add` function. It showcases Zig's syntax for variable declaration, function arguments, return types, and error handling with `try`.

```zig
const std = @import("std");

pub fn bufferedPrint() !void {
    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const stdout = &stdout_writer.interface;
    try stdout.print("Run `zig build test` to run the tests.\n", .{});
    try stdout.flush();
}

pub fn add(a: i32, b: i32) i32 {
    return a + b;
}
```

--------------------------------

### Get Zig String Length

Source: https://pedropark99.github.io/zig-book/Chapters/01-zig-weird

Shows how to get the length of a Zig string literal using the `.len` attribute. This is an efficient and safe operation provided by Zig.

```zig
const std = @import("std");
var stdout_buffer: [1024]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
const stdout = &stdout_writer.interface;

pub fn main() !void {
    const string_object = "This is an example of string literal in Zig";
    try stdout.print("{d}\n", .{string_object.len});
    try stdout.flush();
}
```

--------------------------------

### Create File with Read Permissions and Read in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

Shows how to create a file ('foo.txt') with read permissions enabled, write data to it, and then read that data back. It utilizes `createFile()` with the `.read = true` option and `seekTo(0)` to reset the read position.

```zig
const cwd = std.fs.cwd();
const io = std.testing.io;
const file = try cwd.createFile(
    "foo.txt",
    .{ .read = true }
);
defer file.close();
_ = try file.writeAll(
    "We are going to read this line\n"
);

var buffer: [300]u8 = undefined;
@memset(buffer[0..], 0);

try file.seekTo(0);
var read_buffer: [1024]u8 = undefined;
var fr = file.reader(io, &read_buffer);
var reader = &fr.interface;

_ = reader.readSliceAll(buffer[0..]) catch 0;

try stdout.print("{s}", .{buffer});
try stdout.flush();__
```

--------------------------------

### Check if String Starts With Substring in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/01-zig-weird

The `std.mem.startsWith()` function checks if a given string begins with a specified substring. It returns `true` if the string starts with the sequence, and `false` otherwise. This is useful for prefix matching.

```zig
const name: []const u8 = "Pedro";
try stdout.print(
    "{any}\n", .{std.mem.startsWith(u8, name, "Pe")}
);
try stdout.flush();
```

--------------------------------

### Zig: Base64 Encode/Decode Usage Example

Source: https://pedropark99.github.io/zig-book/Chapters/01-base64

Demonstrates the usage of the implemented Base64 `encode` and `decode` methods in Zig. It initializes a fixed buffer allocator, defines sample text and its expected encoded form, then encodes and decodes the text, printing the results to standard output.

```zig
var memory_buffer: [1000]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(
    &memory_buffer
);
const allocator = fba.allocator();

const text = "Testing some more stuff";
const etext = "VGVzdGluZyBzb21lIG1vcmUgc3R1ZmY=";
const base64 = Base64.init();
const encoded_text = try base64.encode(
    allocator, text
);
const decoded_text = try base64.decode(
    allocator, etext
);
try stdout.print(
    "Encoded text: {s}\n", .{encoded_text}
);
try stdout.print(
    "Decoded text: {s}\n", .{decoded_text}
);
try stdout.flush();
```

--------------------------------

### Create Directories in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

Demonstrates creating directories using Zig's std.fs module. makeDir() creates a single directory, while makePath() recursively creates subdirectories as needed. Both methods are demonstrated with error handling using try.

```zig
const cwd = std.fs.cwd();
try cwd.makeDir("src");
try cwd.makePath("src/decoders/jpg/");
```

--------------------------------

### JavaScript Example: Using Strings as Keys in a Hashtable

Source: https://pedropark99.github.io/zig-book/Chapters/09-data-structures

A simple JavaScript example demonstrating the common pattern of using string keys to store data in a hashtable object. This illustrates the need for specialized hash map types that support string keys.

```javascript
var people = new Object();
people['Pedro'] = {
    'age': 25,
    'height': 1.67,
    'city': 'Belo Horizonte'
};
```

--------------------------------

### Read File using IO Backend Implementation in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

Demonstrates reading a file ('foo.txt') using a specified IO backend implementation. It opens the file, creates a reader interface by passing the IO object to `file.reader()`, and then reads content into a buffer. The example highlights the pattern of providing an IO backend for file operations, which is also common in networking.

```zig
const cwd = std.fs.cwd();
const file = try cwd.openFile(
    "foo.txt", .{ .mode = .read_only }
);
defer file.close();

var read_buffer: [1024]u8 = undefined;
const io = std.testing.io;
var fr = file.reader(io, &read_buffer);
var reader = &fr.interface;

var buffer: [300]u8 = undefined;
@memset(buffer[0..], 0);
_ = reader.readSliceAll(buffer[0..]) catch 0;

try stdout.print("{s}\n", .{buffer});
try stdout.flush();
```

--------------------------------

### Zig: Build Executable using build() function

Source: https://pedropark99.github.io/zig-book/Chapters/07-build-system

This Zig code snippet demonstrates the basic structure of a `build.zig` file. It defines the required `build()` function, which takes a pointer to `std.Build`. Inside, it adds an executable target named 'hello' and specifies its root module, linking it to a 'hello.zig' source file. Finally, it installs the compiled artifact.

```zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const exe = b.addExecutable(.{
        .name = "hello",
        .root_module = b.createModule(.{
            .root_source_file = b.path("hello.zig"),
            .target = b.graph.host
        })
    });
    b.installArtifact(exe);
}
```

--------------------------------

### Zig Pointer Arithmetic Example

Source: https://pedropark99.github.io/zig-book/Chapters/05-pointers

Demonstrates pointer arithmetic in Zig to iterate through an array. It shows how a pointer can be advanced to access subsequent elements, similar to C. The example prints elements of an array using pointer arithmetic.

```zig
const ar = [_]i32{ 1, 2, 3, 4 };
var ptr: [*]const i32 = &ar;
try stdout.print("{d}\n", .{ptr[0]});
ptr += 1;
try stdout.print("{d}\n", .{ptr[0]});
ptr += 1;
try stdout.print("{d}\n", .{ptr[0]});
try stdout.flush();
```

--------------------------------

### Send HTTP GET Request using Python

Source: https://pedropark99.github.io/zig-book/Chapters/04-http-server

This Python script sends an HTTP GET request to a local server running on `127.0.0.1:3490`. It utilizes the `requests` library to perform the request. This is used to test the Zig server's ability to receive and process incoming connections.

```python
import requests
requests.get("http://127.0.0.1:3490")
```

--------------------------------

### Instantiate and Initialize C User Struct in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/14-zig-c-interop

Demonstrates creating an instance of the C 'User' struct in Zig, initializing its 'id' and 'name' fields, and allocating memory for the string.

```zig
const std = @import("std");
const c = @cImport({
    @cInclude("user.h");
});

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

    var new_user: c.User = undefined;
    new_user.id = 1;
    var user_name = try allocator.alloc(u8, 12);
    defer allocator.free(user_name);
    @memcpy(user_name[0..(user_name.len - 1)], "pedropark99");
    user_name[user_name.len - 1] = 0;
    new_user.name = user_name.ptr;
}
```

--------------------------------

### Zig If/Else Statement Example

Source: https://pedropark99.github.io/zig-book/Chapters/03-structs

Demonstrates the basic syntax and execution of an if/else statement in Zig. It checks a condition and executes one of two code blocks based on the boolean result. The example requires the `stdout` and `flush` functions for printing output.

```zig
const x = 5;
if (x > 10) {
    try stdout.print("x > 10!\n", .{});
} else {
    try stdout.print("x <= 10!\n", .{});
}
try stdout.flush();__
```

--------------------------------

### Customize Zig Build with User Options

Source: https://pedropark99.github.io/zig-book/Chapters/07-build-system

This example shows how to define a user-provided boolean option 'use_zlib' in a Zig build script. The option, controllable via the command line with '-Duse_zlib', determines whether to link the system library 'zlib' to the executable.

```zig
const std = @import("std");
pub fn build(b: *std.Build) void {
    const use_zlib = b.option(
        bool,
        "use_zlib",
        "Should link to zlib?"
    ) orelse false;
    const exe = b.addExecutable(.{
        .name = "hello",
        .root_module = b.createModule(.{
            .root_source_file = b.path("example.zig"),
            .target = b.graph.host
        })
    });
    if (use_zlib) {
        exe.root_module.linkSystemLibrary("zlib", .{});
    }
    b.installArtifact(exe);
}
```

--------------------------------

### Import C Libraries and Open PNG File in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/13-image-filter

This snippet demonstrates how to import necessary C headers (stdio.h, spng.h) using Zig's @cImport, define constants, and open a PNG file in binary read mode ('rb') using the C.fopen function. It includes error handling for file opening and initializes an spng context using C.spng_ctx_new. The PNG file is then associated with the context using C.spng_set_png_file.

```zig
const c = @cImport({
    @cDefine("_NO_CRT_STDIO_INLINE", "1");
    @cInclude("stdio.h");
    @cInclude("spng.h");
});

const path = "pedro_pascal.png";
const file_descriptor = c.fopen(path, "rb");
if (file_descriptor == null) {
    @panic("Could not open file!");
}
const ctx = c.spng_ctx_new(0) orelse unreachable;
_ = c.spng_set_png_file(
    ctx, @ptrCast(file_descriptor)
);

```

--------------------------------

### Detach Thread Example in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/14-threads

Demonstrates creating a new thread, detaching it, and then completing the main program. This example uses the `Thread.spawn` and `detach` methods. The `print_id` function is used to print a thread identifier. Note that the output from the detached thread may not appear if the main program finishes before the thread executes.

```zig
const std = @import("std");
const Thread = std.Thread;
var stdout_buffer: [1024]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
const stdout = &stdout_writer.interface;

fn print_id(id: *const u8) !void {
    try stdout.print("Thread ID: {d}\\n", .{id.*});
    try stdout.flush();
}

pub fn main() !void {
    const id1: u8 = 1;
    const thread1 = try Thread.spawn(.{}, print_id, .{&id1});
    thread1.detach();
    _ = try stdout.write("Finish main\\n");
    try stdout.flush();
}
```

--------------------------------

### Start LLDB Debugger

Source: https://pedropark99.github.io/zig-book/Chapters/02-debugging

Command to launch the LLDB debugger and attach it to a compiled executable. This allows for interactive debugging of the program.

```bash
lldb add_program
```

--------------------------------

### Delete Directory in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

Shows how to delete a directory in Zig using the deleteDir() method from a Dir object. The example deletes the 'src' directory, assuming it was previously created.

```zig
const cwd = std.fs.cwd();
try cwd.deleteDir("src");
```

--------------------------------

### Create and Write to a File in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/12-file-op

Demonstrates creating a new file named 'foo.txt', writing a line of text to it, and ensuring the file is closed using `defer`. This function overwrites existing files.

```zig
const cwd = std.fs.cwd();
const file = try cwd.createFile("foo.txt", .{});
// Don't forget to close the file at the end.
defer file.close();
// Do things with the file ...
_ = try file.writeAll(
    "Writing this line to the file\n"
);__
```

--------------------------------

### Create Zig Slice with Compile-Time Known Length

Source: https://pedropark99.github.io/zig-book/Chapters/01-zig-weird

Demonstrates creating a slice from an array where the start and end indices are known at compile-time. This results in a slice that can be treated as a pointer to an array.

```zig
const arr1 = [10]u64 {
    1, 2, 3, 4, 5,
    6, 7, 8, 9, 10
};
// This slice has a compile-time known range.
// Because we know both the start and end of the range.
const slice = arr1[1..4];
_ = slice;
```

--------------------------------

### Define HTTP Method Enum in Zig

Source: https://pedropark99.github.io/zig-book/Chapters/04-http-server

Defines an enumeration for HTTP methods. Currently, it only supports the GET method. This serves as a base for representing different HTTP request types.

```zig
pub const Method = enum {
    GET
};
```

--------------------------------

### Zig Thread Join with Delay and Multiple Threads

Source: https://pedropark99.github.io/zig-book/Chapters/14-threads

Illustrates joining multiple threads with an intervening delay in Zig. This example spawns two threads, joins the first, waits for two seconds, and then joins the second. It highlights how `join()` synchronizes execution and how shared resources like stdout can lead to interleaved output.

```zig
const std = @import("std");
var stdout_buffer: [1024]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
const stdout = &stdout_writer.interface;
const io = std.testing.io;
const Thread = std.Thread;
const clock: std.Io.Clock = .awake;
fn print_id(id: *const u8) !void {
    try stdout.print("Thread ID: {d}\\n", .{id.*});
    try stdout.flush();
}

pub fn main() !void {
    const id1: u8 = 1;
    const id2: u8 = 2;
    const thread1 = try Thread.spawn(.{}, print_id, .{&id1});
    const thread2 = try Thread.spawn(.{}, print_id, .{&id2});

    _ = try stdout.write("Joining thread 1\\n");
    try stdout.flush();
    thread1.join();

    const duration: std.Io.Duration = .{.nanoseconds = 1000};
    try std.Io.sleep(io, duration, clock);

    _ = try stdout.write("Joining thread 2\\n");
    try stdout.flush();
    thread2.join();
}
```

--------------------------------

### Zig: Iterate Over MultiArrayList Field Array

Source: https://pedropark99.github.io/zig-book/Chapters/09-data-structures

Shows how to iterate over a specific internal array within a MultiArrayList using the items() method. This example iterates through the '.age' array of the 'people' PersonArray.

```zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const Person = struct {
    name: []const u8,
    age: u8,
    height: f32,
};

const PersonArray = std.MultiArrayList(Person);

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var people = PersonArray{};
    defer people.deinit(allocator);

    try people.append(allocator, .{
        .name = "Auguste", .age = 15, .height = 1.54
    });
    try people.append(allocator, .{
        .name = "Elena", .age = 26, .height = 1.65
    });
    try people.append(allocator, .{
        .name = "Michael", .age = 64, .height = 1.87
    });

    for (people.items(.age)) |*age| {
        try stdout.print("Age: {d}
", .{age.*});
    }
    try stdout.flush();
}

```
Tokens:
Raw