Zigに入門する

文字列リテラルとUnicodeコードポイントリテラル
文字列リテラルは、NULL終端バイト配列を指す単一項目の定数ポインタです。文字列リテラルの型は、長さとNULL終端であることの両方を符号化しており、そのためスライスとNULL終端ポインタの両方に型強制できます。文字列リテラルの参照外しを行うと、配列に変換されます。
ZigのソースコードはUTF-8でエンコードされているため、ソースコード内の文字列リテラルに現れる非ASCII文字バイトは、そのUTF-8の意味をそのままZigプログラム内の文字列の内容に持ち込みます。コンパイラによってバイトが変更されることはありません。\xNN表記を使用することで、非UTF-8バイトを文字列リテラルに埋め込むことが可能です。
非ASCII文字を含む文字列のインデックス参照は、UTF-8として有効かどうかに関係なく、個々のバイトを返します。
Unicodeコードポイントリテラルは、整数リテラルと同じcomptime_int型を持ちます。すべてのエスケープシーケンスは、文字列リテラルとUnicodeコードポイントリテラルの両方で有効です。

const bytes = "Hello";
const arr = bytes.*; // Dereference
std.debug.print("bytes: {any}\narr: {any}\n{d}", .{ @TypeOf(bytes), @TypeOf(arr), bytes[5] });

bytes: *const [5:0]u8
arr: [5:0]u8
0

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

// You can return a struct from a function. This is how we do generics
// in Zig:
fn LinkedList(comptime T: type) type {
    return struct {
        pub const Node = struct {
            prev: ?*Node,
            next: ?*Node,
            data: T,
        };

        first: ?*Node,
        last: ?*Node,
        len: usize,
    };
}

// omit

const list = LinkedList(i32){
    .first = null,
    .last = null,
    .len = 0,
};
try expect(list.len == 0);

fn Result(comptime T: type, comptime E: type) type {
    return union(enum) { success: T, err: E };
}

const DivideResult = Result(f64, []const u8);

fn divide(a: f64, b: f64) DivideResult {
    if (b == 0) {
        return .{ .err = "division by zero" };
    }
    return .{ .success = a / b };
}
pub fn main() void {
    for ([_]DivideResult{ divide(1.0, 2.0), divide(1.0, 0.0) }, 0..) |result, i| {
        switch (result) {
            .success => |value| {
                std.debug.print("\n{d}: {d}\n", .{ i, value });
            },
            .err => |err| {
                std.debug.print("\n{d}: {s}\n", .{ i, err });
            },
        }
    }
}

0: 0.5

1: division by zero

fn divide(a: f64, b: f64) DivideResult {
    if (b == 0) {
        return DivideResult{ .err = "division by zero" }; // 省略せずに記載することもできる
    }
    return DivideResult{ .success = a / b }; // 省略せずに記載することもできる
}

fn divide(a: f64, b: f64) DivideResult {
    if (b == 0) {
        return .{ .err = "division by zero" }; // 戻り値のstruct名を省略可能
    }
    return .{ .success = a / b }; // 戻り値のstruct名を省略可能
}

pub fn main() !void {
    var arena = ArenaAllocator.init(default_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();

    // これらはすべて同じメモリ領域を指す可能性がある
    // "可能性がある"というのは最適化の結果であって必ずしも保証されているわけではないっぽい
    const str1 = "hello-world";
    const str2 = comptime "hello" ++ "-" ++ "world";
    const str3 = comptime std.fmt.comptimePrint("{s}-{s}", .{ "hello", "world" });
    // これは別メモリ領域を指す
    const str4 = try std.fmt.allocPrint(allocator, "{s}-{s}", .{ "hello", "world" });

    // アドレスを出力して確認
    std.debug.print("str1: {*}\n", .{str1.ptr});
    std.debug.print("str2: {*}\n", .{str2.ptr});
    std.debug.print("str3: {*}\n", .{str3.ptr});
    std.debug.print("str4: {*}\n", .{str4.ptr});
}

str1: u8@104f9bd5e
str2: u8@104f9bd5e
str3: u8@104f9bd5e
str4: u8@6000013700b0