ziglings メモ

#!/bin/bash

function zig_latest() {
    fname=zig-linux-x86_64-0.8.0-dev.1761+ab5a445d2.tar.xz
    cd /tmp
    curl -sS -O https://ziglang.org/builds/$fname
    tar -xvf $fname
    mv $fname $HOME/.local/share/zig
    sudo ln -snf $HOME/.local/share/zig/zig /usr/local/bin/zig
    rm -rf zig-*
}

zig_latest

$ ghq get ratfactor/ziglings

$ zig build

❯ zig build

         _       _ _
     ___(_) __ _| (_)_ __   __ _ ___
    |_  | |/ _' | | | '_ \ / _' / __|
     / /| | (_| | | | | | | (_| \__ \
    /___|_|\__, |_|_|_| |_|\__, |___/
           |___/           |___/

Compiling 001_hello.zig...
/home/tamago324/.local/share/zig/lib/std/start.zig:330:45: error: 'main' is private
    switch (@typeInfo(@typeInfo(@TypeOf(root.main)).Fn.return_type.?)) {
                                            ^
./exercises/001_hello.zig:19:1: note: declared here
fn main() void {
^
001_hello.zig: The following command exited with error code 1:
/home/tamago324/.local/share/zig/zig build-exe /home/tamago324/ghq/github.com/ratfactor/ziglings/exercises/001_hello.zig --cache-dir /home/tamago324/ghq/github.com/ratfactor
/ziglings/zig-cache --enable-cache

HINT: DON'T PANIC!
Read the error above.
See how it has something to do with 'main'?
Open up the source file as noted and read the comments.
You can do this!
Edit exercises/001_hello.zig and run this again.
To continue from this zigling, use this command:
    zig build 1

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello world!\n", .{});
}

$ zig build 1

❯ zig build 1
Compiling 001_hello.zig...
Checking 001_hello.zig...
PASSED: Hello world!

pub fn foo() void {
  ...
}

  var foo: [3]u32 = [3]u32{1, 2, 10};

  // こんな感じでかける！
  var foo = [_]u32{ 1, 2, 10};

  const length = foo.len;

  // 文字列リテラル
  const s = "Hello";
  // u8 の配列
  const s2 = [_]u8{ 'H', 'e', 'l', 'l', 'o' };

    const numbers = [_]u8{ 1, 3, 5 };
    for (numbers) |n| {
        std.debug.print("{} ", .{n});
    }

fn sum(a: u8, b: u8) u8 {
  return a + b;
}

const コレクション名 = error{
  名前1,
  名前2,
  ...
};

fn sampleFail(n: u8) MyNumberError {
  ...
  return MyNumberError.TooFour;
}

const std = @import("std");

pub fn main() void {
    var a: u8 = 10;
    {
        defer a = 100;
        std.debug.print("{}\n", .{a});
    }
    std.debug.print("{}\n", .{a});
}

// 10
// 100

const std = @import("std");

pub fn main() void {
    var l = [_]u8 {0, 1, 1, 2, 0};

    for (l) |v| {
        switch (v) {
            0 => std.debug.print("zero~\n", .{}),
            1 => std.debug.print("one~\n", .{}),
            // else が必要
            else => std.debug.print("other~\n", .{})
        }
    }
}

// zero~
// one~
// one~
// other~
// zero~

const std = @import("std");

pub fn main() void {
    var s = "hello world!";

    for (s) |v| {
        var upper: u8 = switch (v) {
            'h' => 'H',
            'e' => 'E',
            'l' => 'L',
            'o' => 'O',
            ' ' => ' ',
            else => '?',
        };
        std.debug.print("{c}", .{upper});
    }

}

// HELLO ??O?L??

panic: reached unreachable code

if (errorOrOk) |value| {
    // エラーではないとき
} else |err| {
    // エラーのとき
}

if (n) |value| {
  ...
} else |err| switch (err) {
  MyNumberError.TooBig => ...,
  MyNumberError.TooSmall => ...,
}

const std = @import("std");

const NumError = error{IllegalNumber};

// stdout.print() でエラーが起きるかもだから、 !void とした
pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // getNumber() がエラーを返すかもしれないため、 catch でデフォルト値を指定してみた。
    const my_num: u32 = getNumber() catch 42;

    try stdout.print("my_num={}\n", .{my_num});
}

// Just don't modify this function. It's "perfect" the way it is. :-)
fn getNumber() NumError!u32 {
    if (false) return NumError.IllegalNumber;
    return 42;
}

const std = @import("std");

// 方角
const Direction = enum{
    /// 北
    north,
    /// 南
    south,
    /// 東
    east,
    /// 西
    west,
};

pub fn main() void {
    const directions = [_]Direction {
        Direction.north,
        Direction.south
    };
    for (directions) |d| {
        std.debug.print("{}\n", .{d});
    }
}

// Direction.north
// Direction.south

const Character = struct {
    gold: u32,
    health: u8,
};

// {} の中で . を使っているの違和感あったけど、.プロパティって考えるとしっくりきた
var taro = Character {
    .gold = 500,
    .health = 100,
};

    // 値
    var a: u8 = 6;
    // 値への参照
    var a_pointer: *u8 = &a;

    var b: u8 = undefined;

    // 逆参照 (取得？)
    b = a_pointer.*;

    std.debug.print("a: {}, b: {}", .{ a, b });  // a: 6, b: 6

    const locked: u8 = 4;
    var unlocked: u8 = 10;

    const p1: *const u8 = &locked;
    var p2: *const u8 = &locked;

    const p3: *u8 = &unlocked;
    var p4: *u8 = &unlocked;

    // &unlocked は *u8 だけど、 *const u8 にできる。
    const p5: *const u8 = &unlocked;
    var p6: *const u8 = &unlocked;


    const a: u8 = 100;

    // p1.* = 10;
    // p2.* = 10;
    p2 = &a;

    p3.* += 10; // 20
    std.debug.print("{}\n", .{p3.*});

    p4.* += 20; // 40
    std.debug.print("{}\n", .{p4.*});

    var b: u8 = 100;
    // p4 は *u8 型だから、 a の参照は入れられない (*const u8 だから)
    // p4 = &a;
    p4 = &b;
    std.debug.print("{}\n", .{p4.*}); // 100

    // p5.* += 10;
    p6 = &b;

const std = @import("std");

const Elephant = struct {
    letter: u8,
    tail: *Elephant = undefined,
    visited: bool = false,
};

pub fn main() void {
    var elephantA = Elephant{ .letter = 'A' };
    var elephantB = Elephant{ .letter = 'B' };
    var elephantC = Elephant{ .letter = 'C' };

    // ぐるぐるつなげる
    elephantA.tail = &elephantB;
    elephantB.tail = &elephantC;
    elephantC.tail = &elephantA;

    visitElephants(&elephantA);

    std.debug.print("\n", .{});
}

fn visitElephants(first_elephant: *Elephant) void {
    // なぜ、これをやるのか？
    // e に再代入したいから
    var e = first_elephant;

    // e.*.visited ではない
    while (!e.visited) {
        std.debug.print("Elephant {u}. ", .{e.letter});
        e.visited = true;

        // &e.tail のように & はつけないの？？？
        // elephantA.tail = &elephantB; ってやってるから、いらない！
        e = e.tail;
    }
}

const std = @import("std");

pub fn main() void {
    const normal_int: i32 = 100;
    // i32 か null のどちらかが入る。
    const optional_int: ?i32 = 234;
}

const std = @import("std");

pub fn main() void {
    var optional_int: ?i32 = 234;

    optional_int = null;

    if (optional_int == null) {
        std.debug.print("optional_int is null!", .{});
    } else {
        std.debug.print("optional_int is {}", .{optional_int});
    }
}

    const opt_u32: ?u32 = null;

    // opt_u32 が null の場合、 bar は 100 になる
    const bar = opt_u32 orelse 100;

    std.debug.print("{}\n", .{bar});  // 100

const Alien = struct {
    health: u8,

    pub fn hatch(strength: u8) Alien {
        return Alien{
            .health = strength * 5,
        };
    }

    pub fn zap(self: *Alien, damage: u8) void {
        self.health -= if (damage >= self.health) self.health else damage;
    }
};

pub fn main() void {
    var alien = Alien.hatch(10);

    alien.zap(3);

    std.debug.print("alien health is {}", .{alien.health});
}

var foo: u8 = undefined;

var foo: ?u8 = null;

var foo: MyError!u8 = error;

var foo: void = {};

// @import() はインポートしたコードをそのコードに追加する。
// 以下のようにした場合、 std という構造体に保存され、そこから使用できる。
const std = @import("std");

// 構造体は、メモリ処理に適している。
// 各フィールドはすべて型が指定されていて、サイズがわかる。
// そのサイズを合計すると、その構造体のサイズになる。
// この構造体のサイズは `u32 + u8 + u32`
const Character = struct {
    gold: u32 = 0,
    health: u8 = 100,
    experience: u32 = 0,
};

// 以下のように構造体のインスタンスを作成すると、
// データとしてプログラムに保存されて、命令コードと同様にプログラムの実行時に RAM にロードされる。
// また、メモリ内でのこのデータの相対的な位置は (命令コードに?) ハードコーディングされていて、アドレスも値も変更されない。
// const だから、フィールドも変わらないからハードコーディングできる
const the_narrator = Character{
    .gold = 12,
    .health = 99,
    .experience = 9000,
};

// もし、 var で宣言されていた場合、そのデータのアドレスの場所は変わらないけど、データ自体は変わることがある。 (var だから)
var global_wizard = Character{};

// 関数は特定のアドレスの命令コードになる。
// zig の関数のパラメータは const (不変)。
// パラメータはスタックに保存される。
// CPU はスタックへの追加と削除を特別に (?) サポートしているため、メモリストレージとしては最適。
//
// 関数が実行されると、その関数用のフレームが作成される。 (main() も同様)
pub fn main() void {
    // glorp キャラクターが関数のスタックに保存される。
    // var だから、関数の呼び出しごとに変更可能であるため、スタックに入る
    var glorp = Character{
        .gold = 30,
    };

    // skull_farmer キャラクターは関数で定義されているけど、
    // グローバルな不変データに配置される。
    // 不変であるため、すべての関数呼び出しで同じデータにアクセスできるため (?)
    const skull_farmer = Character{};

    // reward_xp は定数であるため、他のグローバルデータと組み合わせられる。
    // コンパイラによっては、命令コードにリテラル値をインライン化するかもしれない。
    const reward_xp: u32 = 200;

    // @import() でインポートした std は普通のzigの構造体となるため、
    // フィールドと宣言に新しい名前をつけられる。
    // std.debug.print をみると、
    //   debug は std のフィールドで、
    //   printは debug で定義されている関数
    //
    // std.debug.print を print に割り当てる
    const print = std.debug.print;

    // zig の値の割り当てとポインタを見てみる
    //
    // glorp キャラクターにアクセスして、１つのフィールドの値を変更する方法を３つ見てみる

    // 1: 新しい構造体にすべてのフィールドの値をコピーする方法
    // 全く同じフィールドの値を持った、新しい構造体ができる
    var glorp_access1: Character = glorp;
    glorp_access1.gold = 111;
    print("1:{}!. ", .{glorp.gold == glorp_access1.gold});

    // 2: ポインタを取得する方法 (ポインタの変数を var で定義)
    // glorp_access2 は元のglorpのアドレスを指している。
    // NOTE: *const Character ではだめ
    var glorp_access2: *Character = &glorp;
    glorp_access2.gold = 222;
    // glorp_access2.gold は暗黙的に逆参照をしている
    // glorp_access2.*.gold = 222;
    print("2:{}!. ", .{glorp.gold == glorp_access2.gold});

    // 3: ポインタを取得する方法 (ポインタの変数を const で定義)
    // 変数が const なだけで、変数が指しているアドレスの値の変更は可能
    const glorp_access3: *Character = &glorp;
    glorp_access3.gold = 333;
    print("3:{}!. ", .{glorp.gold == glorp_access3.gold});

    // NOTE: *const Character 型のポインタにすると、そのポインタが指すアドレスの値は変更できない。
    //
    // 関数に引数を渡すことは、const に値を割り当てることと同じ。
    // パラメータは不変だから、変更したい場合、他の変数に割り当ててから変更しないといけない

    print("XP before:{}, ", .{glorp.experience});

    levelUp(&glorp, reward_xp);

    print("after:{}.\n", .{glorp.experience});
}

fn levelUp(character_access: *Character, xp: u32) void {
    character_access.experience += xp;
}

const std = @import("std");

pub fn main() void {
    var s = [_]u8 {'h', 'e', 'l', 'l', 'o'};

    // スライスで受け取る
    const a: []u8 = s[0..2];

    for (a) |val| {
        std.debug.print("{c}", .{val});
    }
}

// he