zig std

const std =@import("std");pubfnmain() !void {const stdout = std.io.getStdOut().writer();try stdout.print("Hello, {s}!\n", .{"world"});}

$zig build-exe hello.zig$./helloHello, world!

const std =@import("std");pubfnmain()void {    std.debug.print("Hello, world!\n", .{});}

$zig build-exe hello_again.zig$./hello_againHello, world!

zig test -femit-docs main.zig

const print =@import("std").debug.print;pubfnmain()void {// Comments in Zig start with "//" and end at the next LF byte (end of line).// The line below is a comment and won't be executed.//print("Hello?", .{});    print("Hello, world!\n", .{});// another comment}

$zig build-exe comments.zig$./commentsHello, world!

/// A structure for storing a timestamp, with nanosecond precision (this is a/// multiline doc comment).const Timestamp =struct {/// The number of seconds since the epoch (this is also a doc comment).    seconds:i64,// signed so we can represent pre-1970 (not a doc comment)/// The number of nanoseconds past the second (doc comment again).    nanos:u32,/// Returns a `Timestamp` struct representing the Unix epoch; that is, the/// moment of 1970 Jan 1 00:00:00 UTC (this is a doc comment too).pubfnunixEpoch() Timestamp {return Timestamp{            .seconds =0,            .nanos =0,        };    }};

/// doc-comment//! top-level doc-commentconst std =@import("std");

$zig build-obj invalid_doc-comment.zig/home/andy/dev/zig/doc/langref/invalid_doc-comment.zig:1:16:error:expected type expression, found 'a document comment'/// doc-comment^

pubfnmain()void {}/// End of file

$zig build-obj unattached_doc-comment.zig/home/andy/dev/zig/doc/langref/unattached_doc-comment.zig:3:1:error:unattached documentation comment/// End of file^~~~~~~~~~~~~~~

//! This module provides functions for retrieving the current date and//! time with varying degrees of precision and accuracy. It does not//! depend on libc, but will use functions from it if available.const S =struct {//! Top level comments are allowed inside a container other than a module,//! but it is not very useful.  Currently, when producing the package//! documentation, these comments are ignored.};

// Top-level declarations are order-independent:const print = std.debug.print;const std =@import("std");const os = std.os;const assert = std.debug.assert;pubfnmain()void {// integersconst one_plus_one:i32 =1 +1;    print("1 + 1 = {}\n", .{one_plus_one});// floatsconst seven_div_three:f32 =7.0 /3.0;    print("7.0 / 3.0 = {}\n", .{seven_div_three});// boolean    print("{}\n{}\n{}\n", .{trueandfalse,trueorfalse,        !true,    });// optionalvar optional_value: ?[]constu8 =null;    assert(optional_value ==null);    print("\noptional 1\ntype: {}\nvalue: {?s}\n", .{@TypeOf(optional_value), optional_value,    });    optional_value ="hi";    assert(optional_value !=null);    print("\noptional 2\ntype: {}\nvalue: {?s}\n", .{@TypeOf(optional_value), optional_value,    });// error unionvar number_or_error:anyerror!i32 =error.ArgNotFound;    print("\nerror union 1\ntype: {}\nvalue: {!}\n", .{@TypeOf(number_or_error),        number_or_error,    });    number_or_error =1234;    print("\nerror union 2\ntype: {}\nvalue: {!}\n", .{@TypeOf(number_or_error), number_or_error,    });}

$zig build-exe values.zig$./values1 + 1 = 27.0 / 3.0 = 2.3333333e0falsetruefalseoptional 1type: ?[]const u8value: nulloptional 2type: ?[]const u8value: hierror union 1type: anyerror!i32value: error.ArgNotFounderror union 2type: anyerror!i32value: 1234

const print =@import("std").debug.print;const mem =@import("std").mem;// will be used to compare bytespubfnmain()void {const bytes ="hello";    print("{}\n", .{@TypeOf(bytes)});// *const [5:0]u8    print("{d}\n", .{bytes.len});// 5    print("{c}\n", .{bytes[1]});// 'e'    print("{d}\n", .{bytes[5]});// 0    print("{}\n", .{'e' =='\x65'});// true    print("{d}\n", .{'\u{1f4a9}'});// 128169    print("{d}\n", .{'💯'});// 128175    print("{u}\n", .{'⚡'});    print("{}\n", .{mem.eql(u8,"hello","h\x65llo")});// true    print("{}\n", .{mem.eql(u8,"💯","\xf0\x9f\x92\xaf")});// also trueconst invalid_utf8 ="\xff\xfe";// non-UTF-8 strings are possible with \xNN notation.    print("0x{x}\n", .{invalid_utf8[1]});// indexing them returns individual bytes...    print("0x{x}\n", .{"💯"[1]});// ...as does indexing part-way through non-ASCII characters}

$zig build-exe string_literals.zig$./string_literals*const [5:0]u85e0true128169128175⚡truetrue0xfe0x9f

const hello_world_in_c =\\#include <stdio.h>\\\\int main(int argc, char **argv) {\\    printf("hello world\n");\\    return 0;\\};

const x =1234;fnfoo()void {// It works at file scope as well as inside functions.const y =5678;// Once assigned, an identifier cannot be changed.    y +=1;}pubfnmain()void {    foo();}

$zig build-exe constant_identifier_cannot_change.zig/home/andy/dev/zig/doc/langref/constant_identifier_cannot_change.zig:8:7:error:cannot assign to constant    y += 1;~~^~~~referenced by:    main: /home/andy/dev/zig/doc/langref/constant_identifier_cannot_change.zig:12:8    posixCallMainAndExit: /home/andy/dev/zig/lib/std/start.zig:651:22    4 reference(s) hidden; use '-freference-trace=6' to see all references

const print =@import("std").debug.print;pubfnmain()void {var y:i32 =5678;    y +=1;    print("{d}", .{y});}

$zig build-exe mutable_var.zig$./mutable_var5679

pubfnmain()void {var x:i32;    x =1;}

$zig build-exe var_must_be_initialized.zig/home/andy/dev/zig/doc/langref/var_must_be_initialized.zig:2:15:error:expected '=', found ';'    var x: i32;^

const print =@import("std").debug.print;pubfnmain()void {var x:i32 =undefined;    x =1;    print("{d}", .{x});}

$zig build-exe assign_undefined.zig$./assign_undefined1

const print =@import("std").debug.print;pubfnmain()void {var x:u32 =undefined;var y:u32 =undefined;var z:u32 =undefined;const tuple = .{1,2,3 };    x, y, z = tuple;    print("tuple: x = {}, y = {}, z = {}\n", .{x, y, z});const array = [_]u32{4,5,6 };    x, y, z = array;    print("array: x = {}, y = {}, z = {}\n", .{x, y, z});const vector:@Vector(3,u32) = .{7,8,9 };    x, y, z = vector;    print("vector: x = {}, y = {}, z = {}\n", .{x, y, z});}

$zig build-exe destructuring_to_existing.zig$./destructuring_to_existingtuple: x = 1, y = 2, z = 3array: x = 4, y = 5, z = 6vector: x = 7, y = 8, z = 9

const print =@import("std").debug.print;pubfnmain()void {var x:u32 =undefined;const tuple = .{1,2,3 };    x,var y :u32,const z = tuple;    print("x = {}, y = {}, z = {}\n", .{x, y, z});// y is mutable    y =100;// You can use _ to throw away unwanted values.    _, x, _ = tuple;    print("x = {}", .{x});}

$zig build-exe destructuring_mixed.zig$./destructuring_mixedx = 1, y = 2, z = 3x = 2

const std =@import("std");test"expect addOne adds one to 41" {// The Standard Library contains useful functions to help create tests.// `expect` is a function that verifies its argument is true.// It will return an error if its argument is false to indicate a failure.// `try` is used to return an error to the test runner to notify it that the test failed.try std.testing.expect(addOne(41) ==42);}test addOne {// A test name can also be written using an identifier.// This is a doctest, and serves as documentation for `addOne`.try std.testing.expect(addOne(41) ==42);}/// The function `addOne` adds one to the number given as its argument.fnaddOne(number:i32)i32 {return number +1;}

$zig test testing_introduction.zig1/2 testing_introduction.test.expect addOne adds one to 41...OK2/2 testing_introduction.decltest.addOne...OKAll 2 tests passed.

const std =@import("std");test"expect this to fail" {try std.testing.expect(false);}test"expect this to succeed" {try std.testing.expect(true);}

$zig test testing_failure.zig1/2 testing_failure.test.expect this to fail...FAIL (TestUnexpectedResult)/home/andy/dev/zig/lib/std/testing.zig:580:14:0x104890f in expect (test)    if (!ok) return error.TestUnexpectedResult;^/home/andy/dev/zig/doc/langref/testing_failure.zig:4:5:0x10489a5 in test.expect this to fail (test)    try std.testing.expect(false);^2/2 testing_failure.test.expect this to succeed...OK1 passed; 0 skipped; 1 failed.error: the following test command failed with exit code 1:/home/andy/dev/zig/.zig-cache/o/37b2473244f3a3046525f6f7b1b36e1a/test --seed=0xd1a8ca45

test"this will be skipped" {returnerror.SkipZigTest;}

$zig test testing_skip.zig1/1 testing_skip.test.this will be skipped...SKIP0 passed; 1 skipped; 0 failed.

const std =@import("std");test"detect leak" {var list = std.ArrayList(u21).init(std.testing.allocator);// missing `defer list.deinit();`try list.append('☔');try std.testing.expect(list.items.len ==1);}

$zig test testing_detect_leak.zig1/1 testing_detect_leak.test.detect leak...OK[gpa] (err): memory address 0x7ff59fee0000 leaked:/home/andy/dev/zig/lib/std/array_list.zig:474:67:0x10696b2 in ensureTotalCapacityPrecise (test)                const new_memory = try self.allocator.alignedAlloc(T, alignment, new_capacity);^/home/andy/dev/zig/lib/std/array_list.zig:450:51:0x104eb90 in ensureTotalCapacity (test)            return self.ensureTotalCapacityPrecise(better_capacity);^/home/andy/dev/zig/lib/std/array_list.zig:500:41:0x104cebf in addOne (test)            try self.ensureTotalCapacity(newlen);^/home/andy/dev/zig/lib/std/array_list.zig:261:49:0x104a9dd in append (test)            const new_item_ptr = try self.addOne();^/home/andy/dev/zig/doc/langref/testing_detect_leak.zig:6:20:0x1048c75 in test.detect leak (test)    try list.append('☔');^/home/andy/dev/zig/lib/compiler/test_runner.zig:214:25:0x10f7f25 in mainTerminal (test)        if (test_fn.func()) |_| {^/home/andy/dev/zig/lib/compiler/test_runner.zig:62:28:0x10f1f6d in main (test)        return mainTerminal();^/home/andy/dev/zig/lib/std/start.zig:651:22:0x10f13e2 in posixCallMainAndExit (test)            root.main();^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10f0fbd in _start (test)    asm volatile (switch (native_arch) {^All 1 tests passed.1 errors were logged.1 tests leaked memory.error: the following test command failed with exit code 1:/home/andy/dev/zig/.zig-cache/o/ce49f9d6b44eb0d79178a6c6bd6f2b47/test --seed=0x507d4597

const std =@import("std");const builtin =@import("builtin");const expect = std.testing.expect;test"builtin.is_test" {try expect(isATest());}fnisATest()bool {return builtin.is_test;}

$zig test testing_detect_test.zig1/1 testing_detect_test.test.builtin.is_test...OKAll 1 tests passed.

const std =@import("std");test"expectEqual demo" {const expected:i32 =42;const actual =42;// The first argument to `expectEqual` is the known, expected, result.// The second argument is the result of some expression.// The actual's type is casted to the type of expected.try std.testing.expectEqual(expected, actual);}test"expectError demo" {const expected_error =error.DemoError;const actual_error_union:anyerror!void =error.DemoError;// `expectError` will fail when the actual error is different than// the expected error.try std.testing.expectError(expected_error, actual_error_union);}

$zig test testing_namespace.zig1/2 testing_namespace.test.expectEqual demo...OK2/2 testing_namespace.test.expectError demo...OKAll 2 tests passed.

const @"identifier with spaces in it" =0xff;const @"1SmallStep4Man" =112358;const c =@import("std").c;pubextern"c"fn@"error"()void;pubextern"c"fn@"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat)c_int;const Color =enum {    red,    @"really red",};const color: Color = .@"really red";

var y:i32 = add(10, x);const x:i32 = add(12,34);test"container level variables" {try expect(x ==46);try expect(y ==56);}fnadd(a:i32, b:i32)i32 {return a + b;}const std =@import("std");const expect = std.testing.expect;

$zig test test_container_level_variables.zig1/1 test_container_level_variables.test.container level variables...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"namespaced container level variable" {try expect(foo() ==1235);try expect(foo() ==1236);}const S =struct {var x:i32 =1234;};fnfoo()i32 {    S.x +=1;return S.x;}

$zig test test_namespaced_container_level_variable.zig1/1 test_namespaced_container_level_variable.test.namespaced container level variable...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"static local variable" {try expect(foo() ==1235);try expect(foo() ==1236);}fnfoo()i32 {const S =struct {var x:i32 =1234;    };    S.x +=1;return S.x;}

$zig test test_static_local_variable.zig1/1 test_static_local_variable.test.static local variable...OKAll 1 tests passed.

const std =@import("std");const assert = std.debug.assert;threadlocalvar x:i32 =1234;test"thread local storage" {const thread1 =try std.Thread.spawn(.{}, testTls, .{});const thread2 =try std.Thread.spawn(.{}, testTls, .{});    testTls();    thread1.join();    thread2.join();}fntestTls()void {    assert(x ==1234);    x +=1;    assert(x ==1235);}

$zig test test_thread_local_variables.zig1/1 test_thread_local_variables.test.thread local storage...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"comptime vars" {var x:i32 =1;comptimevar y:i32 =1;    x +=1;    y +=1;try expect(x ==2);try expect(y ==2);if (y !=2) {// This compile error never triggers because y is a comptime variable,// and so `y != 2` is a comptime value, and this if is statically evaluated.@compileError("wrong y value");    }}

$zig test test_comptime_variables.zig1/1 test_comptime_variables.test.comptime vars...OKAll 1 tests passed.

const decimal_int =98222;const hex_int =0xff;const another_hex_int =0xFF;const octal_int =0o755;const binary_int =0b11110000;// underscores may be placed between two digits as a visual separatorconst one_billion =1_000_000_000;const binary_mask =0b1_1111_1111;const permissions =0o7_5_5;const big_address =0xFF80_0000_0000_0000;

fndivide(a:i32, b:i32)i32 {return a / b;}

const floating_point =123.0E+77;const another_float =123.0;const yet_another =123.0e+77;const hex_floating_point =0x103.70p-5;const another_hex_float =0x103.70;const yet_another_hex_float =0x103.70P-5;// underscores may be placed between two digits as a visual separatorconst lightspeed =299_792_458.000_000;const nanosecond =0.000_000_001;const more_hex =0x1234_5678.9ABC_CDEFp-10;

const std =@import("std");const inf = std.math.inf(f32);const negative_inf = -std.math.inf(f64);const nan = std.math.nan(f128);

const std =@import("std");const big =@as(f64,1 <<40);exportfnfoo_strict(x:f64)f64 {return x + big - big;}exportfnfoo_optimized(x:f64)f64 {@setFloatMode(.optimized);return x + big - big;}

$zig build-obj float_mode_obj.zig -O ReleaseFast

const print =@import("std").debug.print;externfnfoo_strict(x:f64)f64;externfnfoo_optimized(x:f64)f64;pubfnmain()void {const x =0.001;    print("optimized = {}\n", .{foo_optimized(x)});    print("strict = {}\n", .{foo_strict(x)});}

const expect =@import("std").testing.expect;const assert =@import("std").debug.assert;const mem =@import("std").mem;// array literalconst message = [_]u8{'h','e','l','l','o' };// alternative initialization using result locationconst alt_message: [5]u8 = .{'h','e','l','l','o' };comptime {    assert(mem.eql(u8, &message, &alt_message));}// get the size of an arraycomptime {    assert(message.len ==5);}// A string literal is a single-item pointer to an array.const same_message ="hello";comptime {    assert(mem.eql(u8, &message, same_message));}test"iterate over an array" {var sum:usize =0;for (message) |byte| {        sum += byte;    }try expect(sum =='h' +'e' +'l' *2 +'o');}// modifiable arrayvar some_integers: [100]i32 =undefined;test"modify an array" {for (&some_integers,0..) |*item, i| {        item.* =@intCast(i);    }try expect(some_integers[10] ==10);try expect(some_integers[99] ==99);}// array concatenation works if the values are known// at compile timeconst part_one = [_]i32{1,2,3,4 };const part_two = [_]i32{5,6,7,8 };const all_of_it = part_one ++ part_two;comptime {    assert(mem.eql(i32, &all_of_it, &[_]i32{1,2,3,4,5,6,7,8 }));}// remember that string literals are arraysconst hello ="hello";const world ="world";const hello_world = hello ++" " ++ world;comptime {    assert(mem.eql(u8, hello_world,"hello world"));}// ** does repeating patternsconst pattern ="ab" **3;comptime {    assert(mem.eql(u8, pattern,"ababab"));}// initialize an array to zeroconst all_zero = [_]u16{0} **10;comptime {    assert(all_zero.len ==10);    assert(all_zero[5] ==0);}// use compile-time code to initialize an arrayvar fancy_array = init: {var initial_value: [10]Point =undefined;for (&initial_value,0..) |*pt, i| {        pt.* = Point{            .x =@intCast(i),            .y =@intCast(i *2),        };    }break :init initial_value;};const Point =struct {    x:i32,    y:i32,};test"compile-time array initialization" {try expect(fancy_array[4].x ==4);try expect(fancy_array[4].y ==8);}// call a function to initialize an arrayvar more_points = [_]Point{makePoint(3)} **10;fnmakePoint(x:i32) Point {return Point{        .x = x,        .y = x *2,    };}test"array initialization with function calls" {try expect(more_points[4].x ==3);try expect(more_points[4].y ==6);try expect(more_points.len ==10);}

$zig test test_arrays.zig1/4 test_arrays.test.iterate over an array...OK2/4 test_arrays.test.modify an array...OK3/4 test_arrays.test.compile-time array initialization...OK4/4 test_arrays.test.array initialization with function calls...OKAll 4 tests passed.

const std =@import("std");const expect = std.testing.expect;const expectEqual = std.testing.expectEqual;const mat4x5 = [4][5]f32{    [_]f32{1.0,0.0,0.0,0.0,0.0 },    [_]f32{0.0,1.0,0.0,1.0,0.0 },    [_]f32{0.0,0.0,1.0,0.0,0.0 },    [_]f32{0.0,0.0,0.0,1.0,9.9 },};test"multidimensional arrays" {// mat4x5 itself is a one-dimensional array of arrays.try expectEqual(mat4x5[1], [_]f32{0.0,1.0,0.0,1.0,0.0 });// Access the 2D array by indexing the outer array, and then the inner array.try expect(mat4x5[3][4] ==9.9);// Here we iterate with for loops.for (mat4x5,0..) |row, row_index| {for (row,0..) |cell, column_index| {if (row_index == column_index) {try expect(cell ==1.0);            }        }    }// Initialize a multidimensional array to zeros.const all_zero: [4][5]f32 = .{.{0} **5} **4;try expect(all_zero[0][0] ==0);}

$zig test test_multidimensional_arrays.zig1/1 test_multidimensional_arrays.test.multidimensional arrays...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"0-terminated sentinel array" {const array = [_:0]u8{1,2,3,4 };try expect(@TypeOf(array) == [4:0]u8);try expect(array.len ==4);try expect(array[4] ==0);}test"extra 0s in 0-terminated sentinel array" {// The sentinel value may appear earlier, but does not influence the compile-time 'len'.const array = [_:0]u8{1,0,0,4 };try expect(@TypeOf(array) == [4:0]u8);try expect(array.len ==4);try expect(array[4] ==0);}

$zig test test_null_terminated_array.zig1/2 test_null_terminated_array.test.0-terminated sentinel array...OK2/2 test_null_terminated_array.test.extra 0s in 0-terminated sentinel array...OKAll 2 tests passed.

const print =@import("std").debug.print;fnswizzleRgbaToBgra(rgba: [4]u8) [4]u8 {// readable swizzling by destructuringconst r,const g,const b,const a = rgba;return .{ b, g, r, a };}pubfnmain()void {const pos = [_]i32{1,2 };const x,const y = pos;    print("x = {}, y = {}\n", .{x, y});const orange: [4]u8 = .{255,165,0,255 };    print("{any}\n", .{swizzleRgbaToBgra(orange)});}

$zig build-exe destructuring_arrays.zig$./destructuring_arraysx = 1, y = 2{ 0, 165, 255, 255 }

const std =@import("std");const expectEqual = std.testing.expectEqual;test"Basic vector usage" {// Vectors have a compile-time known length and base type.const a =@Vector(4,i32){1,2,3,4 };const b =@Vector(4,i32){5,6,7,8 };// Math operations take place element-wise.const c = a + b;// Individual vector elements can be accessed using array indexing syntax.try expectEqual(6, c[0]);try expectEqual(8, c[1]);try expectEqual(10, c[2]);try expectEqual(12, c[3]);}test"Conversion between vectors, arrays, and slices" {// Vectors and fixed-length arrays can be automatically assigned back and forthconst arr1: [4]f32 = [_]f32{1.1,3.2,4.5,5.6 };const vec:@Vector(4,f32) = arr1;const arr2: [4]f32 = vec;try expectEqual(arr1, arr2);// You can also assign from a slice with comptime-known length to a vector using .*const vec2:@Vector(2,f32) = arr1[1..3].*;const slice: []constf32 = &arr1;var offset:u32 =1;// var to make it runtime-known    _ = &offset;// suppress 'var is never mutated' error// To extract a comptime-known length from a runtime-known offset,// first extract a new slice from the starting offset, then an array of// comptime-known lengthconst vec3:@Vector(2,f32) = slice[offset..][0..2].*;try expectEqual(slice[offset], vec2[0]);try expectEqual(slice[offset +1], vec2[1]);try expectEqual(vec2, vec3);}

$zig test test_vector.zig1/2 test_vector.test.Basic vector usage...OK2/2 test_vector.test.Conversion between vectors, arrays, and slices...OKAll 2 tests passed.

const print =@import("std").debug.print;// emulate punpckldqpubfnunpack(x:@Vector(4,f32), y:@Vector(4,f32))@Vector(4,f32) {const a,const c, _, _ = x;const b,const d, _, _ = y;return .{ a, b, c, d };}pubfnmain()void {const x:@Vector(4,f32) = .{1.0,2.0,3.0,4.0 };const y:@Vector(4,f32) = .{5.0,6.0,7.0,8.0 };    print("{}", .{unpack(x, y)});}

$zig build-exe destructuring_vectors.zig$./destructuring_vectors{ 1e0, 5e0, 2e0, 6e0 }

const expect =@import("std").testing.expect;test"address of syntax" {// Get the address of a variable:const x:i32 =1234;const x_ptr = &x;// Dereference a pointer:try expect(x_ptr.* ==1234);// When you get the address of a const variable, you get a const single-item pointer.try expect(@TypeOf(x_ptr) == *consti32);// If you want to mutate the value, you'd need an address of a mutable variable:var y:i32 =5678;const y_ptr = &y;try expect(@TypeOf(y_ptr) == *i32);    y_ptr.* +=1;try expect(y_ptr.* ==5679);}test"pointer array access" {// Taking an address of an individual element gives a// single-item pointer. This kind of pointer// does not support pointer arithmetic.var array = [_]u8{1,2,3,4,5,6,7,8,9,10 };const ptr = &array[2];try expect(@TypeOf(ptr) == *u8);try expect(array[2] ==3);    ptr.* +=1;try expect(array[2] ==4);}test"slice syntax" {// Get a pointer to a variable:var x:i32 =1234;const x_ptr = &x;// Convert to array pointer using slice syntax:const x_array_ptr = x_ptr[0..1];try expect(@TypeOf(x_array_ptr) == *[1]i32);// Coerce to many-item pointer:const x_many_ptr: [*]i32 = x_array_ptr;try expect(x_many_ptr[0] ==1234);}

$zig test test_single_item_pointer.zig1/3 test_single_item_pointer.test.address of syntax...OK2/3 test_single_item_pointer.test.pointer array access...OK3/3 test_single_item_pointer.test.slice syntax...OKAll 3 tests passed.

const expect =@import("std").testing.expect;test"pointer arithmetic with many-item pointer" {const array = [_]i32{1,2,3,4 };var ptr: [*]consti32 = &array;try expect(ptr[0] ==1);    ptr +=1;try expect(ptr[0] ==2);// slicing a many-item pointer without an end is equivalent to// pointer arithmetic: `ptr[start..] == ptr + start`try expect(ptr[1..] == ptr +1);// subtraction between any two pointers except slices based on element size is supportedtry expect(&ptr[1] - &ptr[0] ==1);}test"pointer arithmetic with slices" {var array = [_]i32{1,2,3,4 };var length:usize =0;// var to make it runtime-known    _ = &length;// suppress 'var is never mutated' errorvar slice = array[length..array.len];try expect(slice[0] ==1);try expect(slice.len ==4);    slice.ptr +=1;// now the slice is in an bad state since len has not been updatedtry expect(slice[0] ==2);try expect(slice.len ==4);}

$zig test test_pointer_arithmetic.zig1/2 test_pointer_arithmetic.test.pointer arithmetic with many-item pointer...OK2/2 test_pointer_arithmetic.test.pointer arithmetic with slices...OKAll 2 tests passed.

const expect =@import("std").testing.expect;test"pointer slicing" {var array = [_]u8{1,2,3,4,5,6,7,8,9,10 };var start:usize =2;// var to make it runtime-known    _ = &start;// suppress 'var is never mutated' errorconst slice = array[start..4];try expect(slice.len ==2);try expect(array[3] ==4);    slice[1] +=1;try expect(array[3] ==5);}

$zig test test_slice_bounds.zig1/1 test_slice_bounds.test.pointer slicing...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"comptime pointers" {comptime {var x:i32 =1;const ptr = &x;        ptr.* +=1;        x +=1;try expect(ptr.* ==3);    }}

$zig test test_comptime_pointers.zig1/1 test_comptime_pointers.test.comptime pointers...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"@intFromPtr and @ptrFromInt" {const ptr: *i32 =@ptrFromInt(0xdeadbee0);const addr =@intFromPtr(ptr);try expect(@TypeOf(addr) ==usize);try expect(addr ==0xdeadbee0);}

$zig test test_integer_pointer_conversion.zig1/1 test_integer_pointer_conversion.test.@intFromPtr and @ptrFromInt...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"comptime @ptrFromInt" {comptime {// Zig is able to do this at compile-time, as long as// ptr is never dereferenced.const ptr: *i32 =@ptrFromInt(0xdeadbee0);const addr =@intFromPtr(ptr);try expect(@TypeOf(addr) ==usize);try expect(addr ==0xdeadbee0);    }}

$zig test test_comptime_pointer_conversion.zig1/1 test_comptime_pointer_conversion.test.comptime @ptrFromInt...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"pointer casting" {const bytesalign(@alignOf(u32)) = [_]u8{0x12,0x12,0x12,0x12 };const u32_ptr: *constu32 =@ptrCast(&bytes);try expect(u32_ptr.* ==0x12121212);// Even this example is contrived - there are better ways to do the above than// pointer casting. For example, using a slice narrowing cast:const u32_value = std.mem.bytesAsSlice(u32, bytes[0..])[0];try expect(u32_value ==0x12121212);// And even another way, the most straightforward way to do it:try expect(@as(u32,@bitCast(bytes)) ==0x12121212);}test"pointer child type" {// pointer types have a `child` field which tells you the type they point to.try expect(@typeInfo(*u32).pointer.child ==u32);}

$zig test test_pointer_casting.zig1/2 test_pointer_casting.test.pointer casting...OK2/2 test_pointer_casting.test.pointer child type...OKAll 2 tests passed.

const expect =@import("std").testing.expect;test"volatile" {const mmio_ptr: *volatileu8 =@ptrFromInt(0x12345678);try expect(@TypeOf(mmio_ptr) == *volatileu8);}

$zig test test_volatile.zig1/1 test_volatile.test.volatile...OKAll 1 tests passed.

const std =@import("std");const builtin =@import("builtin");const expect = std.testing.expect;test"variable alignment" {var x:i32 =1234;const align_of_i32 =@alignOf(@TypeOf(x));try expect(@TypeOf(&x) == *i32);try expect(*i32 == *align(align_of_i32)i32);if (builtin.target.cpu.arch == .x86_64) {try expect(@typeInfo(*i32).pointer.alignment ==4);    }}

$zig test test_variable_alignment.zig1/1 test_variable_alignment.test.variable alignment...OKAll 1 tests passed.

const expect =@import("std").testing.expect;var foo:u8align(4) =100;test"global variable alignment" {try expect(@typeInfo(@TypeOf(&foo)).pointer.alignment ==4);try expect(@TypeOf(&foo) == *align(4)u8);const as_pointer_to_array: *align(4) [1]u8 = &foo;const as_slice: []align(4)u8 = as_pointer_to_array;const as_unaligned_slice: []u8 = as_slice;try expect(as_unaligned_slice[0] ==100);}fnderp()align(@sizeOf(usize) *2)i32 {return1234;}fnnoop1()align(1)void {}fnnoop4()align(4)void {}test"function alignment" {try expect(derp() ==1234);try expect(@TypeOf(derp) ==fn ()i32);try expect(@TypeOf(&derp) == *align(@sizeOf(usize) *2)constfn ()i32);    noop1();try expect(@TypeOf(noop1) ==fn ()void);try expect(@TypeOf(&noop1) == *align(1)constfn ()void);    noop4();try expect(@TypeOf(noop4) ==fn ()void);try expect(@TypeOf(&noop4) == *align(4)constfn ()void);}

$zig test test_variable_func_alignment.zig1/2 test_variable_func_alignment.test.global variable alignment...OK2/2 test_variable_func_alignment.test.function alignment...OKAll 2 tests passed.

const std =@import("std");test"pointer alignment safety" {var arrayalign(4) = [_]u32{0x11111111,0x11111111 };const bytes = std.mem.sliceAsBytes(array[0..]);try std.testing.expect(foo(bytes) ==0x11111111);}fnfoo(bytes: []u8)u32 {const slice4 = bytes[1..5];const int_slice = std.mem.bytesAsSlice(u32,@as([]align(4)u8,@alignCast(slice4)));return int_slice[0];}

$zig test test_incorrect_pointer_alignment.zig1/1 test_incorrect_pointer_alignment.test.pointer alignment safety...thread 198705 panic: incorrect alignment/home/andy/dev/zig/doc/langref/test_incorrect_pointer_alignment.zig:10:68:0x1048b82 in foo (test)    const int_slice = std.mem.bytesAsSlice(u32, @as([]align(4) u8, @alignCast(slice4)));^/home/andy/dev/zig/doc/langref/test_incorrect_pointer_alignment.zig:6:31:0x1048a2f in test.pointer alignment safety (test)    try std.testing.expect(foo(bytes) == 0x11111111);^/home/andy/dev/zig/lib/compiler/test_runner.zig:214:25:0x10ef475 in mainTerminal (test)        if (test_fn.func()) |_| {^/home/andy/dev/zig/lib/compiler/test_runner.zig:62:28:0x10e785d in main (test)        return mainTerminal();^/home/andy/dev/zig/lib/std/start.zig:651:22:0x10e6cd2 in posixCallMainAndExit (test)            root.main();^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10e68ad in _start (test)    asm volatile (switch (native_arch) {^???:?:?:0x0 in ??? (???)error: the following test command crashed:/home/andy/dev/zig/.zig-cache/o/c74c6fc05a4afb04990e9fe5ae00c4c0/test --seed=0x77765cb4

const std =@import("std");const expect = std.testing.expect;test"allowzero" {var zero:usize =0;// var to make to runtime-known    _ = &zero;// suppress 'var is never mutated' errorconst ptr: *allowzeroi32 =@ptrFromInt(zero);try expect(@intFromPtr(ptr) ==0);}

$zig test test_allowzero.zig1/1 test_allowzero.test.allowzero...OKAll 1 tests passed.

const std =@import("std");// This is also available as `std.c.printf`.pubextern"c"fnprintf(format: [*:0]constu8, ...)c_int;pubfnmain()anyerror!void {    _ = printf("Hello, world!\n");// OKconst msg ="Hello, world!\n";const non_null_terminated_msg: [msg.len]u8 = msg.*;    _ = printf(&non_null_terminated_msg);}

$zig build-exe sentinel-terminated_pointer.zig -lc/home/andy/dev/zig/doc/langref/sentinel-terminated_pointer.zig:11:16:error:expected type '[*:0]const u8', found '*const [14]u8'    _ = printf(&non_null_terminated_msg);^~~~~~~~~~~~~~~~~~~~~~~~/home/andy/dev/zig/doc/langref/sentinel-terminated_pointer.zig:11:16:note:destination pointer requires '0' sentinel/home/andy/dev/zig/doc/langref/sentinel-terminated_pointer.zig:4:34:note:parameter type declared herepub extern "c" fn printf(format: [*:0]const u8, ...) c_int;^~~~~~~~~~~~~referenced by:    main: /home/andy/dev/zig/lib/std/start.zig:660:37    comptime: /home/andy/dev/zig/lib/std/start.zig:58:30    2 reference(s) hidden; use '-freference-trace=4' to see all references

const expect =@import("std").testing.expect;const expectEqualSlices =@import("std").testing.expectEqualSlices;test"basic slices" {var array = [_]i32{1,2,3,4 };var known_at_runtime_zero:usize =0;    _ = &known_at_runtime_zero;const slice = array[known_at_runtime_zero..array.len];// alternative initialization using result locationconst alt_slice: []consti32 = &.{1,2,3,4 };try expectEqualSlices(i32, slice, alt_slice);try expect(@TypeOf(slice) == []i32);try expect(&slice[0] == &array[0]);try expect(slice.len == array.len);// If you slice with comptime-known start and end positions, the result is// a pointer to an array, rather than a slice.const array_ptr = array[0..array.len];try expect(@TypeOf(array_ptr) == *[array.len]i32);// You can perform a slice-by-length by slicing twice. This allows the compiler// to perform some optimisations like recognising a comptime-known length when// the start position is only known at runtime.var runtime_start:usize =1;    _ = &runtime_start;const length =2;const array_ptr_len = array[runtime_start..][0..length];try expect(@TypeOf(array_ptr_len) == *[length]i32);// Using the address-of operator on a slice gives a single-item pointer.try expect(@TypeOf(&slice[0]) == *i32);// Using the `ptr` field gives a many-item pointer.try expect(@TypeOf(slice.ptr) == [*]i32);try expect(@intFromPtr(slice.ptr) ==@intFromPtr(&slice[0]));// Slices have array bounds checking. If you try to access something out// of bounds, you'll get a safety check failure:    slice[10] +=1;// Note that `slice.ptr` does not invoke safety checking, while `&slice[0]`// asserts that the slice has len > 0.// Empty slices can be created like this:const empty1 = &[0]u8{};// If the type is known you can use this short hand:const empty2: []u8 = &.{};try expect(empty1.len ==0);try expect(empty2.len ==0);// A zero-length initialization can always be used to create an empty slice, even if the slice is mutable.// This is because the pointed-to data is zero bits long, so its immutability is irrelevant.}

$zig test test_basic_slices.zig1/1 test_basic_slices.test.basic slices...thread 200412 panic: index out of bounds: index 10, len 4/home/andy/dev/zig/doc/langref/test_basic_slices.zig:41:10:0x104b511 in test.basic slices (test)    slice[10] += 1;^/home/andy/dev/zig/lib/compiler/test_runner.zig:214:25:0x10f2925 in mainTerminal (test)        if (test_fn.func()) |_| {^/home/andy/dev/zig/lib/compiler/test_runner.zig:62:28:0x10ead0d in main (test)        return mainTerminal();^/home/andy/dev/zig/lib/std/start.zig:651:22:0x10ea182 in posixCallMainAndExit (test)            root.main();^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10e9d5d in _start (test)    asm volatile (switch (native_arch) {^???:?:?:0x0 in ??? (???)error: the following test command crashed:/home/andy/dev/zig/.zig-cache/o/59dc8382d8140cff64d1ea721c83a213/test --seed=0x2837bf4f

const std =@import("std");const expect = std.testing.expect;const mem = std.mem;const fmt = std.fmt;test"using slices for strings" {// Zig has no concept of strings. String literals are const pointers// to null-terminated arrays of u8, and by convention parameters// that are "strings" are expected to be UTF-8 encoded slices of u8.// Here we coerce *const [5:0]u8 and *const [6:0]u8 to []const u8const hello: []constu8 ="hello";const world: []constu8 ="世界";var all_together: [100]u8 =undefined;// You can use slice syntax with at least one runtime-known index on an// array to convert an array into a slice.var start:usize =0;    _ = &start;const all_together_slice = all_together[start..];// String concatenation example.const hello_world =try fmt.bufPrint(all_together_slice,"{s} {s}", .{ hello, world });// Generally, you can use UTF-8 and not worry about whether something is a// string. If you don't need to deal with individual characters, no need// to decode.try expect(mem.eql(u8, hello_world,"hello 世界"));}test"slice pointer" {var array: [10]u8 =undefined;const ptr = &array;try expect(@TypeOf(ptr) == *[10]u8);// A pointer to an array can be sliced just like an array:var start:usize =0;var end:usize =5;    _ = .{ &start, &end };const slice = ptr[start..end];// The slice is mutable because we sliced a mutable pointer.try expect(@TypeOf(slice) == []u8);    slice[2] =3;try expect(array[2] ==3);// Again, slicing with comptime-known indexes will produce another pointer// to an array:const ptr2 = slice[2..3];try expect(ptr2.len ==1);try expect(ptr2[0] ==3);try expect(@TypeOf(ptr2) == *[1]u8);}

$zig test test_slices.zig1/2 test_slices.test.using slices for strings...OK2/2 test_slices.test.slice pointer...OKAll 2 tests passed.

const std =@import("std");const expect = std.testing.expect;test"0-terminated slice" {const slice: [:0]constu8 ="hello";try expect(slice.len ==5);try expect(slice[5] ==0);}

$zig test test_null_terminated_slice.zig1/1 test_null_terminated_slice.test.0-terminated slice...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"0-terminated slicing" {var array = [_]u8{3,2,1,0,3,2,1,0 };var runtime_length:usize =3;    _ = &runtime_length;const slice = array[0..runtime_length :0];try expect(@TypeOf(slice) == [:0]u8);try expect(slice.len ==3);}

$zig test test_null_terminated_slicing.zig1/1 test_null_terminated_slicing.test.0-terminated slicing...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"sentinel mismatch" {var array = [_]u8{3,2,1,0 };// Creating a sentinel-terminated slice from the array with a length of 2// will result in the value `1` occupying the sentinel element position.// This does not match the indicated sentinel value of `0` and will lead// to a runtime panic.var runtime_length:usize =2;    _ = &runtime_length;const slice = array[0..runtime_length :0];    _ = slice;}

$zig test test_sentinel_mismatch.zig1/1 test_sentinel_mismatch.test.sentinel mismatch...thread 201174 panic: sentinel mismatch: expected 0, found 1/home/andy/dev/zig/doc/langref/test_sentinel_mismatch.zig:13:24:0x1048a71 in test.sentinel mismatch (test)    const slice = array[0..runtime_length :0];^/home/andy/dev/zig/lib/compiler/test_runner.zig:214:25:0x10ef1d5 in mainTerminal (test)        if (test_fn.func()) |_| {^/home/andy/dev/zig/lib/compiler/test_runner.zig:62:28:0x10e75bd in main (test)        return mainTerminal();^/home/andy/dev/zig/lib/std/start.zig:651:22:0x10e6a32 in posixCallMainAndExit (test)            root.main();^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10e660d in _start (test)    asm volatile (switch (native_arch) {^???:?:?:0x0 in ??? (???)error: the following test command crashed:/home/andy/dev/zig/.zig-cache/o/3ae1c7f3e7c9fd9d03520f85869dba54/test --seed=0xcab5d72d

// Declare a struct.// Zig gives no guarantees about the order of fields and the size of// the struct but the fields are guaranteed to be ABI-aligned.const Point =struct {    x:f32,    y:f32,};// Declare an instance of a struct.const p: Point = .{    .x =0.12,    .y =0.34,};// Functions in the struct's namespace can be called with dot syntax.const Vec3 =struct {    x:f32,    y:f32,    z:f32,pubfninit(x:f32, y:f32, z:f32) Vec3 {return Vec3{            .x = x,            .y = y,            .z = z,        };    }pubfndot(self: Vec3, other: Vec3)f32 {return self.x * other.x + self.y * other.y + self.z * other.z;    }};test"dot product" {const v1 = Vec3.init(1.0,0.0,0.0);const v2 = Vec3.init(0.0,1.0,0.0);try expect(v1.dot(v2) ==0.0);// Other than being available to call with dot syntax, struct methods are// not special. You can reference them as any other declaration inside// the struct:try expect(Vec3.dot(v1, v2) ==0.0);}// Structs can have declarations.// Structs can have 0 fields.const Empty =struct {pubconst PI =3.14;};test"struct namespaced variable" {try expect(Empty.PI ==3.14);try expect(@sizeOf(Empty) ==0);// Empty structs can be instantiated the same as usual.const does_nothing: Empty = .{};    _ = does_nothing;}// Struct field order is determined by the compiler, however, a base pointer// can be computed from a field pointer:fnsetYBasedOnX(x: *f32, y:f32)void {const point: *Point =@fieldParentPtr("x", x);    point.y = y;}test"field parent pointer" {var point = Point{        .x =0.1234,        .y =0.5678,    };    setYBasedOnX(&point.x,0.9);try expect(point.y ==0.9);}// Structs can be returned from functions.fnLinkedList(comptime T:type)type {returnstruct {pubconst Node =struct {            prev: ?*Node,            next: ?*Node,            data: T,        };        first: ?*Node,        last: ?*Node,        len:usize,    };}test"linked list" {// Functions called at compile-time are memoized.try expect(LinkedList(i32) == LinkedList(i32));const list = LinkedList(i32){        .first =null,        .last =null,        .len =0,    };try expect(list.len ==0);// Since types are first class values you can instantiate the type// by assigning it to a variable:const ListOfInts = LinkedList(i32);try expect(ListOfInts == LinkedList(i32));var node = ListOfInts.Node{        .prev =null,        .next =null,        .data =1234,    };const list2 = LinkedList(i32){        .first = &node,        .last = &node,        .len =1,    };// When using a pointer to a struct, fields can be accessed directly,// without explicitly dereferencing the pointer.// So you can dotry expect(list2.first.?.data ==1234);// instead of try expect(list2.first.?.*.data == 1234);}const expect =@import("std").testing.expect;

$zig test test_structs.zig1/4 test_structs.test.dot product...OK2/4 test_structs.test.struct namespaced variable...OK3/4 test_structs.test.field parent pointer...OK4/4 test_structs.test.linked list...OKAll 4 tests passed.

const Foo =struct {    a:i32 =1234,    b:i32,};test"default struct initialization fields" {const x: Foo = .{        .b =5,    };if (x.a + x.b !=1239) {comptimeunreachable;    }}

$zig test struct_default_field_values.zig1/1 struct_default_field_values.test.default struct initialization fields...OKAll 1 tests passed.

const Threshold =struct {    minimum:f32 =0.25,    maximum:f32 =0.75,const Category =enum { low, medium, high };fncategorize(t: Threshold, value:f32) Category {        assert(t.maximum >= t.minimum);if (value < t.minimum)return .low;if (value > t.maximum)return .high;return .medium;    }};pubfnmain() !void {var threshold: Threshold = .{        .maximum =0.20,    };const category = threshold.categorize(0.90);try std.io.getStdOut().writeAll(@tagName(category));}const std =@import("std");const assert = std.debug.assert;

$zig build-exe bad_default_value.zig$./bad_default_valuethread 206555 panic: reached unreachable code/home/andy/dev/zig/lib/std/debug.zig:550:14:0x1048dbd in assert (bad_default_value)    if (!ok) unreachable; // assertion failure^/home/andy/dev/zig/doc/langref/bad_default_value.zig:8:15:0x10de7d9 in categorize (bad_default_value)        assert(t.maximum >= t.minimum);^/home/andy/dev/zig/doc/langref/bad_default_value.zig:19:42:0x10de71a in main (bad_default_value)    const category = threshold.categorize(0.90);^/home/andy/dev/zig/lib/std/start.zig:660:37:0x10de62a in posixCallMainAndExit (bad_default_value)            const result = root.main() catch |err| {^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10de1dd in _start (bad_default_value)    asm volatile (switch (native_arch) {^???:?:?:0x0 in ??? (???)(process terminated by signal)

const Threshold =struct {    minimum:f32,    maximum:f32,const default: Threshold = .{        .minimum =0.25,        .maximum =0.75,    };};

const std =@import("std");const native_endian =@import("builtin").target.cpu.arch.endian();const expect = std.testing.expect;const Full =packedstruct {    number:u16,};const Divided =packedstruct {    half1:u8,    quarter3:u4,    quarter4:u4,};test"@bitCast between packed structs" {try doTheTest();trycomptime doTheTest();}fndoTheTest() !void {try expect(@sizeOf(Full) ==2);try expect(@sizeOf(Divided) ==2);const full = Full{ .number =0x1234 };const divided: Divided =@bitCast(full);try expect(divided.half1 ==0x34);try expect(divided.quarter3 ==0x2);try expect(divided.quarter4 ==0x1);const ordered: [2]u8 =@bitCast(full);switch (native_endian) {        .big => {try expect(ordered[0] ==0x12);try expect(ordered[1] ==0x34);        },        .little => {try expect(ordered[0] ==0x34);try expect(ordered[1] ==0x12);        },    }}

$zig test test_packed_structs.zig1/1 test_packed_structs.test.@bitCast between packed structs...OKAll 1 tests passed.

test"missized packed struct" {const S =packedstruct(u32) { a:u16, b:u8 };    _ = S{ .a =4, .b =2 };}

$zig test test_missized_packed_struct.zig/home/andy/dev/zig/doc/langref/test_missized_packed_struct.zig:2:29:error:backing integer type 'u32' has bit size 32 but the struct fields have a total bit size of 24    const S = packed struct(u32) { a: u16, b: u8 };^~~referenced by:    test.missized packed struct: /home/andy/dev/zig/doc/langref/test_missized_packed_struct.zig:2:22

const std =@import("std");const expect = std.testing.expect;const BitField =packedstruct {    a:u3,    b:u3,    c:u2,};var foo = BitField{    .a =1,    .b =2,    .c =3,};test"pointer to non-byte-aligned field" {const ptr = &foo.b;try expect(ptr.* ==2);}

$zig test test_pointer_to_non-byte_aligned_field.zig1/1 test_pointer_to_non-byte_aligned_field.test.pointer to non-byte-aligned field...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const BitField =packedstruct {    a:u3,    b:u3,    c:u2,};var bit_field = BitField{    .a =1,    .b =2,    .c =3,};test"pointer to non-byte-aligned field" {try expect(bar(&bit_field.b) ==2);}fnbar(x: *constu3)u3 {return x.*;}

$zig test test_misaligned_pointer.zig/home/andy/dev/zig/doc/langref/test_misaligned_pointer.zig:17:20:error:expected type '*const u3', found '*align(1:3:1) u3'    try expect(bar(&bit_field.b) == 2);^~~~~~~~~~~~/home/andy/dev/zig/doc/langref/test_misaligned_pointer.zig:17:20:note:pointer host size '1' cannot cast into pointer host size '0'/home/andy/dev/zig/doc/langref/test_misaligned_pointer.zig:17:20:note:pointer bit offset '3' cannot cast into pointer bit offset '0'/home/andy/dev/zig/doc/langref/test_misaligned_pointer.zig:20:11:note:parameter type declared herefn bar(x: *const u3) u3 {^~~~~~~~~

const std =@import("std");const expect = std.testing.expect;const BitField =packedstruct {    a:u3,    b:u3,    c:u2,};var bit_field = BitField{    .a =1,    .b =2,    .c =3,};test"pointers of sub-byte-aligned fields share addresses" {try expect(@intFromPtr(&bit_field.a) ==@intFromPtr(&bit_field.b));try expect(@intFromPtr(&bit_field.a) ==@intFromPtr(&bit_field.c));}

$zig test test_packed_struct_field_address.zig1/1 test_packed_struct_field_address.test.pointers of sub-byte-aligned fields share addresses...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const BitField =packedstruct {    a:u3,    b:u3,    c:u2,};test"offsets of non-byte-aligned fields" {comptime {try expect(@bitOffsetOf(BitField,"a") ==0);try expect(@bitOffsetOf(BitField,"b") ==3);try expect(@bitOffsetOf(BitField,"c") ==6);try expect(@offsetOf(BitField,"a") ==0);try expect(@offsetOf(BitField,"b") ==0);try expect(@offsetOf(BitField,"c") ==0);    }}

$zig test test_bitOffsetOf_offsetOf.zig1/1 test_bitOffsetOf_offsetOf.test.offsets of non-byte-aligned fields...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const S =packedstruct {    a:u32,    b:u32,};test"overaligned pointer to packed struct" {var foo: Salign(4) = .{ .a =1, .b =2 };const ptr: *align(4) S = &foo;const ptr_to_b: *u32 = &ptr.b;try expect(ptr_to_b.* ==2);}

$zig test test_overaligned_packed_struct.zig1/1 test_overaligned_packed_struct.test.overaligned pointer to packed struct...OKAll 1 tests passed.

const std =@import("std");const expectEqual = std.testing.expectEqual;test"aligned struct fields" {const S =struct {        a:u32align(2),        b:u32align(64),    };var foo = S{ .a =1, .b =2 };try expectEqual(64,@alignOf(S));try expectEqual(*align(2)u32,@TypeOf(&foo.a));try expectEqual(*align(64)u32,@TypeOf(&foo.b));}

$zig test test_aligned_struct_fields.zig1/1 test_aligned_struct_fields.test.aligned struct fields...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"packed struct equality" {const S =packedstruct {        a:u4,        b:u4,    };const x: S = .{ .a =1, .b =2 };const y: S = .{ .b =2, .a =1 };try expect(x == y);}

$zig test test_packed_struct_equality.zig1/1 test_packed_struct_equality.test.packed struct equality...OKAll 1 tests passed.

const std =@import("std");pubfnmain()void {const Foo =struct {};    std.debug.print("variable: {s}\n", .{@typeName(Foo)});    std.debug.print("anonymous: {s}\n", .{@typeName(struct {})});    std.debug.print("function: {s}\n", .{@typeName(List(i32))});}fnList(comptime T:type)type {returnstruct {        x: T,    };}

$zig build-exe struct_name.zig$./struct_namevariable: struct_name.main.Fooanonymous: struct_name.main__struct_24147function: struct_name.List(i32)

const std =@import("std");const expect = std.testing.expect;const Point =struct { x:i32, y:i32 };test"anonymous struct literal" {const pt: Point = .{        .x =13,        .y =67,    };try expect(pt.x ==13);try expect(pt.y ==67);}

$zig test test_struct_result.zig1/1 test_struct_result.test.anonymous struct literal...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"fully anonymous struct" {try check(.{        .int =@as(u32,1234),        .float =@as(f64,12.34),        .b =true,        .s ="hi",    });}fncheck(args:anytype) !void {try expect(args.int ==1234);try expect(args.float ==12.34);try expect(args.b);try expect(args.s[0] =='h');try expect(args.s[1] =='i');}

$zig test test_anonymous_struct.zig1/1 test_anonymous_struct.test.fully anonymous struct...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test"tuple" {const values = .{@as(u32,1234),@as(f64,12.34),true,"hi",    } ++ .{false} **2;try expect(values[0] ==1234);try expect(values[4] ==false);inlinefor (values,0..) |v, i| {if (i !=2)continue;try expect(v);    }try expect(values.len ==6);try expect(values.@"3"[0] =='h');}

$zig test test_tuples.zig1/1 test_tuples.test.tuple...OKAll 1 tests passed.

const print =@import("std").debug.print;pubfnmain()void {const digits = [_]i8 {3,8,9,0,7,4,1 };const min,const max = blk: {var min:i8 =127;var max:i8 = -128;for (digits) |digit| {if (digit < min) min = digit;if (digit > max) max = digit;        }break :blk .{ min, max };    };    print("min = {}", .{ min });    print("max = {}", .{ max });}

$zig build-exe destructuring_block.zig$./destructuring_blockmin = 0max = 9

const print =@import("std").debug.print;fndivmod(numerator:u32, denominator:u32)struct {u32,u32 } {return .{ numerator / denominator, numerator % denominator };}pubfnmain()void {const div,const mod = divmod(10,3);    print("10 / 3 = {}\n", .{div});    print("10 % 3 = {}\n", .{mod});}

$zig build-exe destructuring_return_value.zig$./destructuring_return_value10 / 3 = 310 % 3 = 1

const expect =@import("std").testing.expect;const mem =@import("std").mem;// Declare an enum.const Type =enum {    ok,    not_ok,};// Declare a specific enum field.const c = Type.ok;// If you want access to the ordinal value of an enum, you// can specify the tag type.const Value =enum(u2) {    zero,    one,    two,};// Now you can cast between u2 and Value.// The ordinal value starts from 0, counting up by 1 from the previous member.test"enum ordinal value" {try expect(@intFromEnum(Value.zero) ==0);try expect(@intFromEnum(Value.one) ==1);try expect(@intFromEnum(Value.two) ==2);}// You can override the ordinal value for an enum.const Value2 =enum(u32) {    hundred =100,    thousand =1000,    million =1000000,};test"set enum ordinal value" {try expect(@intFromEnum(Value2.hundred) ==100);try expect(@intFromEnum(Value2.thousand) ==1000);try expect(@intFromEnum(Value2.million) ==1000000);}// You can also override only some values.const Value3 =enum(u4) {    a,    b =8,    c,    d =4,    e,};test"enum implicit ordinal values and overridden values" {try expect(@intFromEnum(Value3.a) ==0);try expect(@intFromEnum(Value3.b) ==8);try expect(@intFromEnum(Value3.c) ==9);try expect(@intFromEnum(Value3.d) ==4);try expect(@intFromEnum(Value3.e) ==5);}// Enums can have methods, the same as structs and unions.// Enum methods are not special, they are only namespaced// functions that you can call with dot syntax.const Suit =enum {    clubs,    spades,    diamonds,    hearts,pubfnisClubs(self: Suit)bool {return self == Suit.clubs;    }};test"enum method" {const p = Suit.spades;try expect(!p.isClubs());}// An enum can be switched upon.const Foo =enum {    string,    number,    none,};test"enum switch" {const p = Foo.number;const what_is_it =switch (p) {        Foo.string =>"this is a string",        Foo.number =>"this is a number",        Foo.none =>"this is a none",    };try expect(mem.eql(u8, what_is_it,"this is a number"));}// @typeInfo can be used to access the integer tag type of an enum.const Small =enum {    one,    two,    three,    four,};test"std.meta.Tag" {try expect(@typeInfo(Small).@"enum".tag_type ==u2);}// @typeInfo tells us the field count and the fields names:test"@typeInfo" {try expect(@typeInfo(Small).@"enum".fields.len ==4);try expect(mem.eql(u8,@typeInfo(Small).@"enum".fields[1].name,"two"));}// @tagName gives a [:0]const u8 representation of an enum value:test"@tagName" {try expect(mem.eql(u8,@tagName(Small.three),"three"));}

$zig test test_enums.zig1/8 test_enums.test.enum ordinal value...OK2/8 test_enums.test.set enum ordinal value...OK3/8 test_enums.test.enum implicit ordinal values and overridden values...OK4/8 test_enums.test.enum method...OK5/8 test_enums.test.enum switch...OK6/8 test_enums.test.std.meta.Tag...OK7/8 test_enums.test.@typeInfo...OK8/8 test_enums.test.@tagName...OKAll 8 tests passed.

const Foo =enum { a, b, c };exportfnentry(foo: Foo)void {    _ = foo;}

$zig build-obj enum_export_error.zig -target x86_64-linux/home/andy/dev/zig/doc/langref/enum_export_error.zig:2:17:error:parameter of type 'enum_export_error.Foo' not allowed in function with calling convention 'x86_64_sysv'export fn entry(foo: Foo) void {^~~~~~~~/home/andy/dev/zig/doc/langref/enum_export_error.zig:2:17:note:enum tag type 'u2' is not extern compatible/home/andy/dev/zig/doc/langref/enum_export_error.zig:2:17:note:only integers with 0, 8, 16, 32, 64 and 128 bits are extern compatible/home/andy/dev/zig/doc/langref/enum_export_error.zig:1:13:note:enum declared hereconst Foo = enum { a, b, c };^~~~~~~~~~~~~~~~referenced by:    root: /home/andy/dev/zig/lib/std/start.zig:3:22    comptime: /home/andy/dev/zig/lib/std/start.zig:27:9    2 reference(s) hidden; use '-freference-trace=4' to see all references

const Foo =enum(c_int) { a, b, c };exportfnentry(foo: Foo)void {    _ = foo;}

$zig build-obj enum_export.zig

const std =@import("std");const expect = std.testing.expect;const Color =enum {    auto,    off,    on,};test"enum literals" {const color1: Color = .auto;const color2 = Color.auto;try expect(color1 == color2);}test"switch using enum literals" {const color = Color.on;const result =switch (color) {        .auto =>false,        .on =>true,        .off =>false,    };try expect(result);}

$zig test test_enum_literals.zig1/2 test_enum_literals.test.enum literals...OK2/2 test_enum_literals.test.switch using enum literals...OKAll 2 tests passed.

const std =@import("std");const expect = std.testing.expect;const Number =enum(u8) {    one,    two,    three,    _,};test"switch on non-exhaustive enum" {const number = Number.one;const result =switch (number) {        .one =>true,        .two, .three =>false,        _ =>false,    };try expect(result);const is_one =switch (number) {        .one =>true,else =>false,    };try expect(is_one);}

$zig test test_switch_non-exhaustive.zig1/1 test_switch_non-exhaustive.test.switch on non-exhaustive enum...OKAll 1 tests passed.

const Payload =union {    int:i64,    float:f64,    boolean:bool,};test"simple union" {var payload = Payload{ .int =1234 };    payload.float =12.34;}

$zig test test_wrong_union_access.zig1/1 test_wrong_union_access.test.simple union...thread 210915 panic: access of union field 'float' while field 'int' is active/home/andy/dev/zig/doc/langref/test_wrong_union_access.zig:8:12:0x1048a5f in test.simple union (test)    payload.float = 12.34;^/home/andy/dev/zig/lib/compiler/test_runner.zig:214:25:0x10ef2e5 in mainTerminal (test)        if (test_fn.func()) |_| {^/home/andy/dev/zig/lib/compiler/test_runner.zig:62:28:0x10e76cd in main (test)        return mainTerminal();^/home/andy/dev/zig/lib/std/start.zig:651:22:0x10e6b42 in posixCallMainAndExit (test)            root.main();^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10e671d in _start (test)    asm volatile (switch (native_arch) {^???:?:?:0x0 in ??? (???)error: the following test command crashed:/home/andy/dev/zig/.zig-cache/o/0e2ad1837ee3fe26786cd418343cba9e/test --seed=0xdea5f103

const std =@import("std");const expect = std.testing.expect;const Payload =union {    int:i64,    float:f64,    boolean:bool,};test"simple union" {var payload = Payload{ .int =1234 };try expect(payload.int ==1234);    payload = Payload{ .float =12.34 };try expect(payload.float ==12.34);}

$zig test test_simple_union.zig1/1 test_simple_union.test.simple union...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const ComplexTypeTag =enum {    ok,    not_ok,};const ComplexType =union(ComplexTypeTag) {    ok:u8,    not_ok:void,};test"switch on tagged union" {const c = ComplexType{ .ok =42 };try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);switch (c) {        .ok => |value|try expect(value ==42),        .not_ok =>unreachable,    }}test"get tag type" {try expect(std.meta.Tag(ComplexType) == ComplexTypeTag);}

$zig test test_tagged_union.zig1/2 test_tagged_union.test.switch on tagged union...OK2/2 test_tagged_union.test.get tag type...OKAll 2 tests passed.

const std =@import("std");const expect = std.testing.expect;const ComplexTypeTag =enum {    ok,    not_ok,};const ComplexType =union(ComplexTypeTag) {    ok:u8,    not_ok:void,};test"modify tagged union in switch" {var c = ComplexType{ .ok =42 };switch (c) {        ComplexTypeTag.ok => |*value| value.* +=1,        ComplexTypeTag.not_ok =>unreachable,    }try expect(c.ok ==43);}

$zig test test_switch_modify_tagged_union.zig1/1 test_switch_modify_tagged_union.test.modify tagged union in switch...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const Variant =union(enum) {    int:i32,    boolean:bool,// void can be omitted when inferring enum tag type.    none,fntruthy(self: Variant)bool {returnswitch (self) {            Variant.int => |x_int| x_int !=0,            Variant.boolean => |x_bool| x_bool,            Variant.none =>false,        };    }};test"union method" {var v1: Variant = .{ .int =1 };var v2: Variant = .{ .boolean =false };var v3: Variant = .none;try expect(v1.truthy());try expect(!v2.truthy());try expect(!v3.truthy());}

$zig test test_union_method.zig1/1 test_union_method.test.union method...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const Small2 =union(enum) {    a:i32,    b:bool,    c:u8,};test"@tagName" {try expect(std.mem.eql(u8,@tagName(Small2.a),"a"));}

$zig test test_tagName.zig1/1 test_tagName.test.@tagName...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const Number =union {    int:i32,    float:f64,};test"anonymous union literal syntax" {const i: Number = .{ .int =42 };const f = makeNumber();try expect(i.int ==42);try expect(f.float ==12.34);}fnmakeNumber() Number {return .{ .float =12.34 };}

$zig test test_anonymous_union.zig1/1 test_anonymous_union.test.anonymous union literal syntax...OKAll 1 tests passed.

const Derp =opaque {};const Wat =opaque {};externfnbar(d: *Derp)void;fnfoo(w: *Wat)callconv(.C)void {    bar(w);}test"call foo" {    foo(undefined);}

$zig test test_opaque.zig/home/andy/dev/zig/doc/langref/test_opaque.zig:6:9:error:expected type '*test_opaque.Derp', found '*test_opaque.Wat'    bar(w);^/home/andy/dev/zig/doc/langref/test_opaque.zig:6:9:note:pointer type child 'test_opaque.Wat' cannot cast into pointer type child 'test_opaque.Derp'/home/andy/dev/zig/doc/langref/test_opaque.zig:2:13:note:opaque declared hereconst Wat = opaque {};^~~~~~~~~/home/andy/dev/zig/doc/langref/test_opaque.zig:1:14:note:opaque declared hereconst Derp = opaque {};^~~~~~~~~/home/andy/dev/zig/doc/langref/test_opaque.zig:4:18:note:parameter type declared hereextern fn bar(d: *Derp) void;^~~~~referenced by:    test.call foo: /home/andy/dev/zig/doc/langref/test_opaque.zig:10:8

test"access variable after block scope" {    {var x:i32 =1;        _ = &x;    }    x +=1;}

$zig test test_blocks.zig/home/andy/dev/zig/doc/langref/test_blocks.zig:6:5:error:use of undeclared identifier 'x'    x += 1;^

const std =@import("std");const expect = std.testing.expect;test"labeled break from labeled block expression" {var y:i32 =123;const x = blk: {        y +=1;break :blk y;    };try expect(x ==124);try expect(y ==124);}

$zig test test_labeled_break.zig1/1 test_labeled_break.test.labeled break from labeled block expression...OKAll 1 tests passed.

const pi =3.14;test"inside test block" {// Let's even go inside another block    {var pi:i32 =1234;    }}

$zig test test_shadowing.zig/home/andy/dev/zig/doc/langref/test_shadowing.zig:6:13:error:local variable shadows declaration of 'pi'        var pi: i32 = 1234;^~/home/andy/dev/zig/doc/langref/test_shadowing.zig:1:1:note:declared hereconst pi = 3.14;^~~~~~~~~~~~~~~

test"separate scopes" {    {const pi =3.14;        _ = pi;    }    {var pi:bool =true;        _ = π    }}

$zig test test_scopes.zig1/1 test_scopes.test.separate scopes...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;test {const a = {};const b =void{};try expect(@TypeOf(a) ==void);try expect(@TypeOf(b) ==void);try expect(a == b);}

$zig test test_empty_block.zig1/1 test_empty_block.test_0...OKAll 1 tests passed.

const std =@import("std");const builtin =@import("builtin");const expect = std.testing.expect;test"switch simple" {const a:u64 =10;const zz:u64 =103;// All branches of a switch expression must be able to be coerced to a// common type.//// Branches cannot fallthrough. If fallthrough behavior is desired, combine// the cases and use an if.const b =switch (a) {// Multiple cases can be combined via a ','1,2,3 =>0,// Ranges can be specified using the ... syntax. These are inclusive// of both ends.5...100 =>1,// Branches can be arbitrarily complex.101 => blk: {const c:u64 =5;break :blk c *2 +1;        },// Switching on arbitrary expressions is allowed as long as the// expression is known at compile-time.        zz => zz,        blk: {const d:u32 =5;const e:u32 =100;break :blk d + e;        } =>107,// The else branch catches everything not already captured.// Else branches are mandatory unless the entire range of values// is handled.else =>9,    };try expect(b ==1);}// Switch expressions can be used outside a function:const os_msg =switch (builtin.target.os.tag) {    .linux =>"we found a linux user",else =>"not a linux user",};// Inside a function, switch statements implicitly are compile-time// evaluated if the target expression is compile-time known.test"switch inside function" {switch (builtin.target.os.tag) {        .fuchsia => {// On an OS other than fuchsia, block is not even analyzed,// so this compile error is not triggered.// On fuchsia this compile error would be triggered.@compileError("fuchsia not supported");        },else => {},    }}

$zig test test_switch.zig1/2 test_switch.test.switch simple...OK2/2 test_switch.test.switch inside function...OKAll 2 tests passed.

const expect =@import("std").testing.expect;test"switch on tagged union" {const Point =struct {        x:u8,        y:u8,    };const Item =union(enum) {        a:u32,        c: Point,        d,        e:u32,    };var a = Item{ .c = Point{ .x =1, .y =2 } };// Switching on more complex enums is allowed.const b =switch (a) {// A capture group is allowed on a match, and will return the enum// value matched. If the payload types of both cases are the same// they can be put into the same switch prong.        Item.a, Item.e => |item| item,// A reference to the matched value can be obtained using `*` syntax.        Item.c => |*item| blk: {            item.*.x +=1;break :blk6;        },// No else is required if the types cases was exhaustively handled        Item.d =>8,    };try expect(b ==6);try expect(a.c.x ==2);}

$zig test test_switch_tagged_union.zig1/1 test_switch_tagged_union.test.switch on tagged union...OKAll 1 tests passed.

const Color =enum {    auto,    off,    on,};test"exhaustive switching" {const color = Color.off;switch (color) {        Color.auto => {},        Color.on => {},    }}

$zig test test_unhandled_enumeration_value.zig/home/andy/dev/zig/doc/langref/test_unhandled_enumeration_value.zig:9:5:error:switch must handle all possibilities    switch (color) {^~~~~~/home/andy/dev/zig/doc/langref/test_unhandled_enumeration_value.zig:3:5:note:unhandled enumeration value: 'off'    off,^~~/home/andy/dev/zig/doc/langref/test_unhandled_enumeration_value.zig:1:15:note:enum 'test_unhandled_enumeration_value.Color' declared hereconst Color = enum {^~~~

const std =@import("std");const expect = std.testing.expect;const Color =enum {    auto,    off,    on,};test"enum literals with switch" {const color = Color.off;const result =switch (color) {        .auto =>false,        .on =>false,        .off =>true,    };try expect(result);}

$zig test test_exhaustive_switch.zig1/1 test_exhaustive_switch.test.enum literals with switch...OKAll 1 tests passed.

const std =@import("std");test"switch continue" {    sw:switch (@as(i32,5)) {5 =>continue :sw4,// `continue` can occur multiple times within a single switch prong.2...4 => |v| {if (v >3) {continue :sw2;            }elseif (v ==3) {// `break` can target labeled loops.break :sw;            }continue :sw1;        },1 =>return,else =>unreachable,    }}

$zig test test_switch_continue.zig1/1 test_switch_continue.test.switch continue...OKAll 1 tests passed.

const std =@import("std");test"switch continue, equivalent loop" {var sw:i32 =5;while (true) {switch (sw) {5 => {                sw =4;continue;            },2...4 => |v| {if (v >3) {                    sw =2;continue;                }elseif (v ==3) {break;                }                sw =1;continue;            },1 =>return,else =>unreachable,        }    }}

$zig test test_switch_continue_equivalent.zig1/1 test_switch_continue_equivalent.test.switch continue, equivalent loop...OKAll 1 tests passed.

const std =@import("std");const expectEqual = std.testing.expectEqual;const Instruction =enum {    add,    mul,    end,};fnevaluate(initial_stack: []consti32, code: []const Instruction) !i32 {var stack =try std.BoundedArray(i32,8).fromSlice(initial_stack);var ip:usize =0;return vm:switch (code[ip]) {// Because all code after `continue` is unreachable, this branch does// not provide a result.        .add => {try stack.append(stack.pop().? + stack.pop().?);            ip +=1;continue :vm code[ip];        },        .mul => {try stack.append(stack.pop().? * stack.pop().?);            ip +=1;continue :vm code[ip];        },        .end => stack.pop().?,    };}test"evaluate" {const result =try evaluate(&.{7,2, -3 }, &.{ .mul, .add, .end });try expectEqual(1, result);}

$zig test test_switch_dispatch_loop.zig1/1 test_switch_dispatch_loop.test.evaluate...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const expectError = std.testing.expectError;fnisFieldOptional(comptime T:type, field_index:usize) !bool {const fields =@typeInfo(T).@"struct".fields;returnswitch (field_index) {// This prong is analyzed twice with `idx` being a// comptime-known value each time.inline0,1 => |idx|@typeInfo(fields[idx].type) == .optional,else =>returnerror.IndexOutOfBounds,    };}const Struct1 =struct { a:u32, b: ?u32 };test"using @typeInfo with runtime values" {var index:usize =0;try expect(!try isFieldOptional(Struct1, index));    index +=1;try expect(try isFieldOptional(Struct1, index));    index +=1;try expectError(error.IndexOutOfBounds, isFieldOptional(Struct1, index));}// Calls to `isFieldOptional` on `Struct1` get unrolled to an equivalent// of this function:fnisFieldOptionalUnrolled(field_index:usize) !bool {returnswitch (field_index) {0 =>false,1 =>true,else =>returnerror.IndexOutOfBounds,    };}

$zig test test_inline_switch.zig1/1 test_inline_switch.test.using @typeInfo with runtime values...OKAll 1 tests passed.

fnisFieldOptional(comptime T:type, field_index:usize) !bool {const fields =@typeInfo(T).@"struct".fields;returnswitch (field_index) {inline0...fields.len -1 => |idx|@typeInfo(fields[idx].type) == .optional,else =>returnerror.IndexOutOfBounds,    };}

const std =@import("std");const expect = std.testing.expect;const SliceTypeA =externstruct {    len:usize,    ptr: [*]u32,};const SliceTypeB =externstruct {    ptr: [*]SliceTypeA,    len:usize,};const AnySlice =union(enum) {    a: SliceTypeA,    b: SliceTypeB,    c: []constu8,    d: []AnySlice,};fnwithFor(any: AnySlice)usize {const Tag =@typeInfo(AnySlice).@"union".tag_type.?;inlinefor (@typeInfo(Tag).@"enum".fields) |field| {// With `inline for` the function gets generated as// a series of `if` statements relying on the optimizer// to convert it to a switch.if (field.value ==@intFromEnum(any)) {return@field(any, field.name).len;        }    }// When using `inline for` the compiler doesn't know that every// possible case has been handled requiring an explicit `unreachable`.unreachable;}fnwithSwitch(any: AnySlice)usize {returnswitch (any) {// With `inline else` the function is explicitly generated// as the desired switch and the compiler can check that// every possible case is handled.inlineelse => |slice| slice.len,    };}test"inline for and inline else similarity" {const any = AnySlice{ .c ="hello" };try expect(withFor(any) ==5);try expect(withSwitch(any) ==5);}

$zig test test_inline_else.zig1/1 test_inline_else.test.inline for and inline else similarity...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const U =union(enum) {    a:u32,    b:f32,};fngetNum(u: U)u32 {switch (u) {// Here `num` is a runtime-known value that is either// `u.a` or `u.b` and `tag` is `u`'s comptime-known tag value.inlineelse => |num, tag| {if (tag == .b) {return@intFromFloat(num);            }return num;        },    }}test"test" {const u = U{ .b =42 };try expect(getNum(u) ==42);}

$zig test test_inline_switch_union_tag.zig1/1 test_inline_switch_union_tag.test.test...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"while basic" {var i:usize =0;while (i <10) {        i +=1;    }try expect(i ==10);}

$zig test test_while.zig1/1 test_while.test.while basic...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"while break" {var i:usize =0;while (true) {if (i ==10)break;        i +=1;    }try expect(i ==10);}

$zig test test_while_break.zig1/1 test_while_break.test.while break...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"while continue" {var i:usize =0;while (true) {        i +=1;if (i <10)continue;break;    }try expect(i ==10);}

$zig test test_while_continue.zig1/1 test_while_continue.test.while continue...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"while loop continue expression" {var i:usize =0;while (i <10) : (i +=1) {}try expect(i ==10);}test"while loop continue expression, more complicated" {var i:usize =1;var j:usize =1;while (i * j <2000) : ({        i *=2;        j *=3;    }) {const my_ij = i * j;try expect(my_ij <2000);    }}

$zig test test_while_continue_expression.zig1/2 test_while_continue_expression.test.while loop continue expression...OK2/2 test_while_continue_expression.test.while loop continue expression, more complicated...OKAll 2 tests passed.

const expect =@import("std").testing.expect;test"while else" {try expect(rangeHasNumber(0,10,5));try expect(!rangeHasNumber(0,10,15));}fnrangeHasNumber(begin:usize, end:usize, number:usize)bool {var i = begin;returnwhile (i < end) : (i +=1) {if (i == number) {breaktrue;        }    }elsefalse;}

$zig test test_while_else.zig1/1 test_while_else.test.while else...OKAll 1 tests passed.

test"nested break" {    outer:while (true) {while (true) {break :outer;        }    }}test"nested continue" {var i:usize =0;    outer:while (i <10) : (i +=1) {while (true) {continue :outer;        }    }}

$zig test test_while_nested_break.zig1/2 test_while_nested_break.test.nested break...OK2/2 test_while_nested_break.test.nested continue...OKAll 2 tests passed.

const expect =@import("std").testing.expect;test"while null capture" {var sum1:u32 =0;    numbers_left =3;while (eventuallyNullSequence()) |value| {        sum1 += value;    }try expect(sum1 ==3);// null capture with an else blockvar sum2:u32 =0;    numbers_left =3;while (eventuallyNullSequence()) |value| {        sum2 += value;    }else {try expect(sum2 ==3);    }// null capture with a continue expressionvar i:u32 =0;var sum3:u32 =0;    numbers_left =3;while (eventuallyNullSequence()) |value| : (i +=1) {        sum3 += value;    }try expect(i ==3);}var numbers_left:u32 =undefined;fneventuallyNullSequence() ?u32 {returnif (numbers_left ==0)nullelse blk: {        numbers_left -=1;break :blk numbers_left;    };}

$zig test test_while_null_capture.zig1/1 test_while_null_capture.test.while null capture...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"while error union capture" {var sum1:u32 =0;    numbers_left =3;while (eventuallyErrorSequence()) |value| {        sum1 += value;    }else |err| {try expect(err ==error.ReachedZero);    }}var numbers_left:u32 =undefined;fneventuallyErrorSequence()anyerror!u32 {returnif (numbers_left ==0)error.ReachedZeroelse blk: {        numbers_left -=1;break :blk numbers_left;    };}

$zig test test_while_error_capture.zig1/1 test_while_error_capture.test.while error union capture...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"inline while loop" {comptimevar i =0;var sum:usize =0;inlinewhile (i <3) : (i +=1) {const T =switch (i) {0 =>f32,1 =>i8,2 =>bool,else =>unreachable,        };        sum += typeNameLength(T);    }try expect(sum ==9);}fntypeNameLength(comptime T:type)usize {return@typeName(T).len;}

$zig test test_inline_while.zig1/1 test_inline_while.test.inline while loop...OKAll 1 tests passed.

const expect =@import("std").testing.expect;test"for basics" {const items = [_]i32{4,5,3,4,0 };var sum:i32 =0;// For loops iterate over slices and arrays.for (items) |value| {// Break and continue are supported.if (value ==0) {continue;        }        sum += value;    }try expect(sum ==16);// To iterate over a portion of a slice, reslice.for (items[0..1]) |value| {        sum += value;    }try expect(sum ==20);// To access the index of iteration, specify a second condition as well// as a second capture value.var sum2:i32 =0;for (items,0..) |_, i| {try expect(@TypeOf(i) ==usize);        sum2 +=@as(i32,@intCast(i));    }try expect(sum2 ==10);// To iterate over consecutive integers, use the range syntax.// Unbounded range is always a compile error.var sum3:usize =0;for (0..5) |i| {        sum3 += i;    }try expect(sum3 ==10);}test"multi object for" {const items = [_]usize{1,2,3 };const items2 = [_]usize{4,5,6 };var count:usize =0;// Iterate over multiple objects.// All lengths must be equal at the start of the loop, otherwise detectable// illegal behavior occurs.for (items, items2) |i, j| {        count += i + j;    }try expect(count ==21);}test"for reference" {var items = [_]i32{3,4,2 };// Iterate over the slice by reference by// specifying that the capture value is a pointer.for (&items) |*value| {        value.* +=1;    }try expect(items[0] ==4);try expect(items[1] ==5);try expect(items[2] ==3);}test"for else" {// For allows an else attached to it, the same as a while loop.const items = [_]?i32{3,4,null,5 };// For loops can also be used as expressions.// Similar to while loops, when you break from a for loop, the else branch is not evaluated.var sum:i32 =0;const result =for (items) |value| {if (value !=null) {            sum += value.?;        }    }else blk: {try expect(sum ==12);break :blk sum;    };try expect(result ==12);}

$zig test test_for.zig1/4 test_for.test.for basics...OK2/4 test_for.test.multi object for...OK3/4 test_for.test.for reference...OK4/4 test_for.test.for else...OKAll 4 tests passed.

const std =@import("std");const expect = std.testing.expect;test"nested break" {var count:usize =0;    outer:for (1..6) |_| {for (1..6) |_| {            count +=1;break :outer;        }    }try expect(count ==1);}test"nested continue" {var count:usize =0;    outer:for (1..9) |_| {for (1..6) |_| {            count +=1;continue :outer;        }    }try expect(count ==8);}

$zig test test_for_nested_break.zig1/2 test_for_nested_break.test.nested break...OK2/2 test_for_nested_break.test.nested continue...OKAll 2 tests passed.

const expect =@import("std").testing.expect;test"inline for loop" {const nums = [_]i32{2,4,6 };var sum:usize =0;inlinefor (nums) |i| {const T =switch (i) {2 =>f32,4 =>i8,6 =>bool,else =>unreachable,        };        sum += typeNameLength(T);    }try expect(sum ==9);}fntypeNameLength(comptime T:type)usize {return@typeName(T).len;}

$zig test test_inline_for.zig1/1 test_inline_for.test.inline for loop...OKAll 1 tests passed.

// If expressions have three uses, corresponding to the three types:// * bool// * ?T// * anyerror!Tconst expect =@import("std").testing.expect;test"if expression" {// If expressions are used instead of a ternary expression.const a:u32 =5;const b:u32 =4;const result =if (a != b)47else3089;try expect(result ==47);}test"if boolean" {// If expressions test boolean conditions.const a:u32 =5;const b:u32 =4;if (a != b) {try expect(true);    }elseif (a ==9) {unreachable;    }else {unreachable;    }}test"if error union" {// If expressions test for errors.// Note the |err| capture on the else.const a:anyerror!u32 =0;if (a) |value| {try expect(value ==0);    }else |err| {        _ = err;unreachable;    }const b:anyerror!u32 =error.BadValue;if (b) |value| {        _ = value;unreachable;    }else |err| {try expect(err ==error.BadValue);    }// The else and |err| capture is strictly required.if (a) |value| {try expect(value ==0);    }else |_| {}// To check only the error value, use an empty block expression.if (b) |_| {}else |err| {try expect(err ==error.BadValue);    }// Access the value by reference using a pointer capture.var c:anyerror!u32 =3;if (c) |*value| {        value.* =9;    }else |_| {unreachable;    }if (c) |value| {try expect(value ==9);    }else |_| {unreachable;    }}

$zig test test_if.zig1/3 test_if.test.if expression...OK2/3 test_if.test.if boolean...OK3/3 test_if.test.if error union...OKAll 3 tests passed.

const expect =@import("std").testing.expect;test"if optional" {// If expressions test for null.const a: ?u32 =0;if (a) |value| {try expect(value ==0);    }else {unreachable;    }const b: ?u32 =null;if (b) |_| {unreachable;    }else {try expect(true);    }// The else is not required.if (a) |value| {try expect(value ==0);    }// To test against null only, use the binary equality operator.if (b ==null) {try expect(true);    }// Access the value by reference using a pointer capture.var c: ?u32 =3;if (c) |*value| {        value.* =2;    }if (c) |value| {try expect(value ==2);    }else {unreachable;    }}test"if error union with optional" {// If expressions test for errors before unwrapping optionals.// The |optional_value| capture's type is ?u32.const a:anyerror!?u32 =0;if (a) |optional_value| {try expect(optional_value.? ==0);    }else |err| {        _ = err;unreachable;    }const b:anyerror!?u32 =null;if (b) |optional_value| {try expect(optional_value ==null);    }else |_| {unreachable;    }const c:anyerror!?u32 =error.BadValue;if (c) |optional_value| {        _ = optional_value;unreachable;    }else |err| {try expect(err ==error.BadValue);    }// Access the value by reference by using a pointer capture each time.var d:anyerror!?u32 =3;if (d) |*optional_value| {if (optional_value.*) |*value| {            value.* =9;        }    }else |_| {unreachable;    }if (d) |optional_value| {try expect(optional_value.? ==9);    }else |_| {unreachable;    }}

$zig test test_if_optionals.zig1/2 test_if_optionals.test.if optional...OK2/2 test_if_optionals.test.if error union with optional...OKAll 2 tests passed.

const std =@import("std");const expect = std.testing.expect;const print = std.debug.print;fndeferExample() !usize {var a:usize =1;    {defer a =2;        a =1;    }try expect(a ==2);    a =5;return a;}test"defer basics" {try expect((try deferExample()) ==5);}

$zig test test_defer.zig1/1 test_defer.test.defer basics...OKAll 1 tests passed.

const std =@import("std");const expect = std.testing.expect;const print = std.debug.print;test"defer unwinding" {    print("\n", .{});defer {        print("1 ", .{});    }defer {        print("2 ", .{});    }if (false) {// defers are not run if they are never executed.defer {            print("3 ", .{});        }    }}

$zig test defer_unwind.zig1/1 defer_unwind.test.defer unwinding...2 1 OKAll 1 tests passed.

fndeferInvalidExample() !void {defer {returnerror.DeferError;    }returnerror.DeferError;}

$zig test test_invalid_defer.zig/home/andy/dev/zig/doc/langref/test_invalid_defer.zig:3:9:error:cannot return from defer expression        return error.DeferError;^~~~~~~~~~~~~~~~~~~~~~~/home/andy/dev/zig/doc/langref/test_invalid_defer.zig:2:5:note:defer expression here    defer {^~~~~

// unreachable is used to assert that control flow will never reach a// particular location:test"basic math" {const x =1;const y =2;if (x + y !=3) {unreachable;    }}

$zig test test_unreachable.zig1/1 test_unreachable.test.basic math...OKAll 1 tests passed.

// This is how std.debug.assert is implementedfnassert(ok:bool)void {if (!ok)unreachable;// assertion failure}// This test will fail because we hit unreachable.test"this will fail" {    assert(false);}

$zig test test_assertion_failure.zig1/1 test_assertion_failure.test.this will fail...thread 209597 panic: reached unreachable code/home/andy/dev/zig/doc/langref/test_assertion_failure.zig:3:14:0x104892d in assert (test)    if (!ok) unreachable; // assertion failure^/home/andy/dev/zig/doc/langref/test_assertion_failure.zig:8:11:0x10488fa in test.this will fail (test)    assert(false);^/home/andy/dev/zig/lib/compiler/test_runner.zig:214:25:0x10ef0c5 in mainTerminal (test)        if (test_fn.func()) |_| {^/home/andy/dev/zig/lib/compiler/test_runner.zig:62:28:0x10e74ad in main (test)        return mainTerminal();^/home/andy/dev/zig/lib/std/start.zig:651:22:0x10e6922 in posixCallMainAndExit (test)            root.main();^/home/andy/dev/zig/lib/std/start.zig:271:5:0x10e64fd in _start (test)    asm volatile (switch (native_arch) {^???:?:?:0x0 in ??? (???)error: the following test command crashed:/home/andy/dev/zig/.zig-cache/o/0594f73810636b148c5e4293efd1faf6/test --seed=0x2a37766c

const assert =@import("std").debug.assert;test"type of unreachable" {comptime {// The type of unreachable is noreturn.// However this assertion will still fail to compile because// unreachable expressions are compile errors.        assert(@TypeOf(unreachable) ==noreturn);    }}

$zig test test_comptime_unreachable.zig/home/andy/dev/zig/doc/langref/test_comptime_unreachable.zig:10:16:error:unreachable code        assert(@TypeOf(unreachable) == noreturn);^~~~~~~~~~~~~~~~~~~~/home/andy/dev/zig/doc/langref/test_comptime_unreachable.zig:10:24:note:control flow is diverted here        assert(@TypeOf(unreachable) == noreturn);^~~~~~~~~~~

fnfoo(condition:bool, b:u32)void {const a =if (condition) belsereturn;    _ = a;@panic("do something with a");}test"noreturn" {    foo(false,1);}

$zig test test_noreturn.zig1/1 test_noreturn.test.noreturn...OKAll 1 tests passed.

const std =@import("std");const builtin =@import("builtin");const native_arch = builtin.cpu.arch;const expect = std.testing.expect;const WINAPI: std.builtin.CallingConvention =if (native_arch == .x86) .Stdcallelse .C;extern"kernel32"fnExitProcess(exit_code:c_uint)callconv(WINAPI)noreturn;test"foo" {const value = bar()catch ExitProcess(1);try expect(value ==1234);}fnbar()anyerror!u32 {return1234;}

$zig test test_noreturn_from_exit.zig -target x86_64-windows --test-no-exec

const std =@import("std");const builtin =@import("builtin");const native_arch = builtin.cpu.arch;const expect = std.testing.expect;// Functions are declared like thisfnadd(a:i8, b:i8)i8 {if (a ==0) {return b;    }return a + b;}// The export specifier makes a function externally visible in the generated// object file, and makes it use the C ABI.exportfnsub(a:i8, b:i8)i8 {return a - b;}// The extern specifier is used to declare a function that will be resolved// at link time, when linking statically, or at runtime, when linking// dynamically. The quoted identifier after the extern keyword specifies// the library that has the function. (e.g. "c" -> libc.so)// The callconv specifier changes the calling convention of the function.const WINAPI: std.builtin.CallingConvention =if (native_arch == .x86) .Stdcallelse .C;extern"kernel32"fnExitProcess(exit_code:u32)callconv(WINAPI)noreturn;extern"c"fnatan2(a:f64, b:f64)f64;// The @branchHint builtin can be used to tell the optimizer that a function is rarely called ("cold").fnabort()noreturn {@branchHint(.cold);while (true) {}}// The naked calling convention makes a function not have any function prologue or epilogue.// This can be useful when integrating with assembly.fn_start()callconv(.Naked)noreturn {    abort();}// The inline calling convention forces a function to be inlined at all call sites.// If the function cannot be inlined, it is a compile-time error.inlinefnshiftLeftOne(a:u32)u32 {return a <<1;}// The pub specifier allows the function to be visible when importing.// Another file can use @import and call sub2pubfnsub2(a:i8, b:i8)i8 {return a - b;}// Function pointers are prefixed with `*const `.const Call2Op = *constfn (a:i8, b:i8)i8;fndoOp(fnCall: Call2Op, op1:i8, op2:i8)i8 {return fnCall(op1, op2);}test"function" {try expect(doOp(add,5,6) ==11);try expect(doOp(sub2,5,6) == -1);}

$zig test test_functions.zig1/1 test_functions.test.function...OKAll 1 tests passed.

const Point =struct {    x:i32,    y:i32,};fnfoo(point: Point)i32 {// Here, `point` could be a reference, or a copy. The function body// can ignore the difference and treat it as a value. Be very careful// taking the address of the parameter - it should be treated as if// the address will become invalid when the function returns.return point.x + point.y;}const expect =@import("std").testing.expect;test"pass struct to function" {try expect(foo(Point{ .x =1, .y =2 }) ==3);}

$zig test test_pass_by_reference_or_value.zig1/1 test_pass_by_reference_or_value.test.pass struct to function...OKAll 1 tests passed.

const expect =@import("std").testing.expect;fnaddFortyTwo(x:anytype)@TypeOf(x) {return x +42;}test"fn type inference" {try expect(addFortyTwo(1) ==43);try expect(@TypeOf(addFortyTwo(1)) ==comptime_int);const y:i64 =2;try expect(addFortyTwo(y) ==44);try expect(@TypeOf(addFortyTwo(y)) ==i64);}

$zig test test_fn_type_inference.zig1/1 test_fn_type_inference.test.fn type inference...OKAll 1 tests passed.

test"inline function call" {if (foo(1200,34) !=1234) {@compileError("bad");    }}inlinefnfoo(a:i32, b:i32)i32 {return a + b;}

$zig test inline_call.zig1/1 inline_call.test.inline function call...OKAll 1 tests passed.

const std =@import("std");const math = std.math;const testing = std.testing;test"fn reflection" {try testing.expect(@typeInfo(@TypeOf(testing.expect)).@"fn".params[0].type.? ==bool);try testing.expect(@typeInfo(@TypeOf(testing.tmpDir)).@"fn".return_type.? == testing.TmpDir);try testing.expect(@typeInfo(@TypeOf(math.Log2Int)).@"fn".is_generic);}

$zig test test_fn_reflection.zig1/1 test_fn_reflection.test.fn reflection...OKAll 1 tests passed.

const std =@import("std");const FileOpenError =error{    AccessDenied,    OutOfMemory,    FileNotFound,};const AllocationError =error{    OutOfMemory,};test"coerce subset to superset" {const err = foo(AllocationError.OutOfMemory);try std.testing.expect(err == FileOpenError.OutOfMemory);}fnfoo(err: AllocationError) FileOpenError {return err;}

$zig test test_coerce_error_subset_to_superset.zig1/1 test_coerce_error_subset_to_superset.test.coerce subset to superset...OKAll 1 tests passed.

const FileOpenError =error{    AccessDenied,    OutOfMemory,    FileNotFound,};const AllocationError =error{    OutOfMemory,};test"coerce superset to subset" {    foo(FileOpenError.OutOfMemory)catch {};}fnfoo(err: FileOpenError) AllocationError {return err;}

$zig test test_coerce_error_superset_to_subset.zig/home/andy/dev/zig/doc/langref/test_coerce_error_superset_to_subset.zig:16:12:error:expected type 'error{OutOfMemory}', found 'error{AccessDenied,OutOfMemory,FileNotFound}'    return err;^~~/home/andy/dev/zig/doc/langref/test_coerce_error_superset_to_subset.zig:16:12:note:'error.AccessDenied' not a member of destination error set/home/andy/dev/zig/doc/langref/test_coerce_error_superset_to_subset.zig:16:12:note:'error.FileNotFound' not a member of destination error set/home/andy/dev/zig/doc/langref/test_coerce_error_superset_to_subset.zig:15:28:note:function return type declared herefn foo(err: FileOpenError) AllocationError {^~~~~~~~~~~~~~~referenced by:    test.coerce superset to subset: /home/andy/dev/zig/doc/langref/test_coerce_error_superset_to_subset.zig:12:8

const err =error.FileNotFound;

const err = (error{FileNotFound}).FileNotFound;

const std =@import("std");const maxInt = std.math.maxInt;pubfnparseU64(buf: []constu8, radix:u8) !u64 {var x:u64 =0;for (buf) |c| {const digit = charToDigit(c);if (digit >= radix) {returnerror.InvalidChar;        }// x *= radixvar ov =@mulWithOverflow(x, radix);if (ov[1] !=0)returnerror.OverFlow;// x += digit        ov =@addWithOverflow(ov[0], digit);if (ov[1] !=0)returnerror.OverFlow;        x = ov[0];    }return x;}fncharToDigit(c:u8)u8 {returnswitch (c) {'0'...'9' => c -'0','A'...'Z' => c -'A' +10,'a'...'z' => c -'a' +10,else => maxInt(u8),    };}test"parse u64" {const result =try parseU64("1234",10);try std.testing.expect(result ==1234);}

$zig test error_union_parsing_u64.zig1/1 error_union_parsing_u64.test.parse u64...OKAll 1 tests passed.