ジグはどのように機能しますか？

翻訳者から：この投稿は、2018年3月15日に著者のブログに公開されました。 言語が進化するにつれて、その構文は現在異なる場合があります。 説明されているものはすべてZig 0.2.0に関連し、言語の現在のバージョンはZig 0.3.0です。



私は投稿の作者に連絡し、彼は親切にZig 0.3.0のプロジェクトソースの現在のバージョンでリポジトリへのリンクを提供しました。



こんにちは Brainfuckインタープリターを作成しましょう！ 「なぜ？」と尋ねることはできますが、ここでは答えが見つかりません。



Zigでそれを行います。

ジグは...

...新しいプログラミング言語。 まだベータ版であり、急速に開発中です。 Zigコードを以前に見たことがあれば、この投稿のコードはあなたとは少し違うように見えるかもしれません。 彼は本当に違う！ Zig 0.2.0がリリースされたばかりで、数週間前のLLVM 6のリリースに合わせて、多くの構文の変更と一般的な言語の改善が含まれています。 ほとんどの場合、多くの「スペル」はキーワードに置き換えられています。 すべての変更の詳細については、 こちらをご覧ください！



Zigは読みやすいように設計されており 、C、C ++、およびRustなどのコンパイルされ型付けされた言語に精通している人にとっては比較的直感的です。



コードは、Zig 0.2.0でコンパイルおよびテストされています。これは、OSXを使用している場合、homebrewを含むさまざまなチャネルからすぐに入手できます。brewinstall zig。

さあ始めましょう

Brainfuckの仕組みについては、 こちらをご覧ください 。 そこで学ぶことはほとんどありませんが、 チューリング完全な言語であるため、 何でも書くことができます。



最終製品や初期のコミットを見たい場合に備えて、 ここにコードを投稿しました。



Zigはコンパイルされた言語です。 プログラムをコンパイルするとき、結果のバイナリ（ライブラリではなく実行可能バイナリをコンパイルする場合）には、エントリポイントをマークするメイン関数が必要です。



だから...

// main.zig fn main() void { }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

...そして開始...

 $ zig build-exe main.zig
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

...配る...

 /zig/std/special/bootstrap.zig:70:33: error: 'main' is private /zigfuck/main.zig:2:1: note: declared here
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

モジュールの外から見えるようにするには、mainをpublicとして宣言する必要があります...

 // main.zig pub fn main() void { }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Brainfuckプログラムが30,000バイトの配列をメモリとして使用するようにします。このような配列を作成します。

 // main.zig pub fn main() void { const mem: [30000]u8; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

定数（const）または変数（var）を宣言できます。 ここでは、memを30,000の符号なし（u）バイト（8ビット）の配列として宣言しました。



これはコンパイルされません。

 /main.zig:3:5: error: variables must be initialized
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

同等のCプログラムは正常にコンパイルされます。初期化せずに変数を宣言できますが、変数が宣言された時点で、Zigがすぐに決定を下すように強制します。 何が書き込まれるかは気にしないかもしれませんが、これを明示的に示す必要があります。 これを行うには、変数を未定義の値（未定義）で初期化します。

 // main.zig pub fn main() void { const mem: [30000]u8 = undefined; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

未定義の値で変数を初期化しても、メモリ内の変数の値に関する保証はありません。 これは、明示的に指定する必要があることを除いて、Cの初期化されていない変数宣言と同じです。



しかし、このメモリを初期化する方法は気にしないかもしれません。 おそらく、ゼロまたは任意の値がそこに書き込まれることを保証したいのです。 この場合、これも明示的に述べる必要があります。

 // main.zig pub fn main() void { const mem = []u8{0} ** 30000; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

奇妙に思えるかもしれませんが、**は配列の展開に使用される演算子です。 0バイトの配列を宣言し、それを30,000に拡張し、30,000バイトの最終初期化値を取得します。 この操作は、 コンパイル時に 1回発生します 。 comptimeはZigの素晴らしいアイデアの1つであり、次の投稿の1つでそれに戻ります。



では、最初のメモリスロットを5回増やすこと以外は何もしないBrainfuckのプログラムを作成しましょう。

 pub fn main() void { const mem = []u8{0} ** 30000; const src = "+++++"; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Zigでは、文字列はバイト配列です。 コンパイラがこれを暗黙指定しているため、srcをバイト配列として宣言しないでください。 これはオプションですが、必要な場合は可能です。

 const src: [5]u8 = "+++++";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これで問題なくコンパイルできます。 ただし、これ：

 const src: [6]u8= "+++++";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

なりません。

 main.zig:5:22: error: expected type '[6]u8', found '[5]u8'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

もう1つの注意：文字列は単なる配列であるため、ゼロで終わることはありません。 ただし、ヌル終了文字列Cを宣言できます。リテラルとしては、次のようになります。

 c"Hello I am a null terminated string";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

一般的な利益のために...

文字列のすべての文字で何かをしたい。 できるよ！ main.zigの冒頭で、標準ライブラリからいくつかの関数をインポートします。

 const warn = @import("std").debug.warn;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

importは、@記号で始まるほぼすべてのものと同様に、 組み込みコンパイラー関数です。 そのような機能は常にグローバルに利用可能です。 ここでのインポートは、javascriptと同様に機能します。ネームスペースを掘り下げて、そこから公開されている関数または変数を抽出することで、何でもインポートできます。 上記の例では、warn関数を直接インポートし、突然、warn定数に割り当てます。 今、彼女を呼び出すことができます。 これは一般的なパターンです。std名前空間から直接インポートしてから、std.debug.warn（）を呼び出すか、warn変数に割り当てます。 次のようになります。

 const std = @import("std"); const warn = std.debug.warn;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 const warn = @import("std").debug.warn; // main.zig pub fn main() void { const mem = []u8{0} ** 30000; const src = "+++++"; for (src) |c| { warn("{}", c); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

デバッグおよび初期開発とテスト中に、画面に何かを印刷したいだけです。 Zigはエラーを起こしやすく 、stdoutもエラーを起こしやすいです。 今はこれをやりたくありません。標準ライブラリからインポートしたwarnを使用してstderrに直接印刷できます。



warnはCのprintfのようなフォーマットされた文字列を受け取ります！ 上記のコードは印刷されます：

 4343434343
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

43はASCII文字コード+です。 私も書くことができます：

 warn("{c}", c);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

取得：

 +++++
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そこで、メモリ空間を初期化し、プログラムを作成しました。 今、私たちは言語そのものを実現しています。 +で開始し、forループの本体をスイッチに置き換えます。

 for (src) |c| { switch(c) { '+' => mem[0] += 1 } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次の2つのエラーが表示されます。

 /main.zig:10:7: error: switch must handle all possibilities switch(c) { ^ /main.zig:11:25: error: cannot assign to constant '+' => mem[0] += 1 ^
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

もちろん、変数に新しい値を割り当てることはできません。これは定数です！ memは変数にする必要があります...

 var mem = []u8{0} ** 30000;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

他のエラーと同様に、私のスイッチ構成は、何もする必要がない場合でも、文字が+でない場合に何をすべきかを知っている必要があります。 私の場合、これはまさに私が望むものです。 このケースを空のブロックで埋めます：

 for (src) |c| { switch(c) { '+' => mem[0] += 1, else => {} } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これでプログラムをコンパイルできます。 最後に警告を呼び出して実行します：

 const warn = @import("std").debug.warn; pub fn main() void { var mem = []u8{0} ** 30000; const src = "+++++"; for (src) |c| { switch(c) { '+' => mem[0] += 1, else => {} } } warn("{}", mem[0]); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

予想どおり、 stderrに数字の5が出力されます。

続けましょう...

同様に、サポートします。

 switch(c) { '+' => mem[0] += 1, '-' => mem[0] -= 1, else => {} }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

>と<を使用するには、追加の変数を使用する必要があります。この変数は、ユーザーBrainfuckプログラムに割り当てたメモリ内の「ポインター」として機能します。

 var memptr: u16 = 0;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

符号なし16ビットは最大65535になる可能性があるため、30,000バイトのアドレス空間をインデックスするには十分です。

実際、15ビットで十分なので、32767バイトをアドレス指定できます。 Zigでは、 異なる幅の型を使用できますが、まだu15は使用できません。



実際にこの方法でu15を実行できます。

 const u15 = @IntType(false, 15):
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

[iu] \ d +型は整数型として有効であることが提案されています。

mem [0]を使用する代わりに、この変数を使用できます。

 '+' => mem[memptr] += 1, '-' => mem[memptr] -= 1,
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

<and>このポインタを単純に増減します。

 '>' => memptr += 1, '<' => memptr -= 1,
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

いいね これで実際のプログラムを書くことができます！

1,2,3を確認します

Zigにはテストエンジンが組み込まれています。 任意のファイルのどこにでもテストブロックを記述できます。

 test "Name of Test" { // test code }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

コマンドラインからテストを実行します：zig test $ FILENAME。 残りのテストブロックは、通常のコードと同じです。



これを見てみましょう：

 // test.zig test "testing tests" {} zig test test.zig Test 1/1 testing tests...OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

もちろん、空のテストは役に立ちません。 assertを使用して、テストの実行を実際に確認できます。

 const assert = @import("std").debug.assert; test "test true" { assert(true); } test "test false" { assert(false); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 zig test test.zig "thing.zig" 10L, 127C written :!zig test thing.zig Test 1/2 test true...OK Test 2/2 test false...assertion failure [37;1m_panic.7 [0m: [2m0x0000000105260f34 in ??? (???) [0m [37;1m_panic [0m: [2m0x0000000105260d6b in ??? (???) [0m [37;1m_assert [0m: [2m0x0000000105260619 in ??? (???) [0m [37;1m_test false [0m: [2m0x0000000105260cfb in ??? (???) [0m [37;1m_main.0 [0m: [2m0x00000001052695ea in ??? (???) [0m [37;1m_callMain [0m: [2m0x0000000105269379 in ??? (???) [0m [37;1m_callMainWithArgs [0m: [2m0x00000001052692f9 in ??? (???) [0m [37;1m_main [0m: [2m0x0000000105269184 in ??? (???) [0m [37;1m??? [0m: [2m0x00007fff5c75c115 in ??? (???) [0m [37;1m??? [0m: [2m0x0000000000000001 in ??? (???) [0m
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

テストは落ちました。 次のコマンドを使用して、エラーを再現します。

 ./zig-cache/test
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ポピーのスタックトレースはまだ開発中です。



これを効率的にテストするには、分解する必要があります。 これから始めましょう：

 fn bf(src: []const u8, mem: [30000]u8) void { var memptr: u16 = 0; for (src) |c| { switch(c) { '+' => mem[memptr] += 1, '-' => mem[memptr] -= 1, '>' => memptr += 1, '<' => memptr -= 1, else => {} } } } pub fn main() void { var mem = []u8{0} ** 30000; const src = "+++++"; bf(src, mem); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

うまくいくはずですよね？



しかし...

 /main.zig:1:29: error: type '[30000]u8' is not copyable; cannot pass by value
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これはhttps://github.com/zig-lang/zig/issues/733で説明されています 。

Zigはこれについて厳格です。 複合型、およびサイズ変更可能なすべてのオブジェクトは、値で渡すことはできません。 これにより、スタックの割り当てが予測可能かつ論理的になり、不要なコピーが回避されます。 プログラムで値による転送のセマンティクスを使用する場合は、割り当て戦略を使用して自分で実装できますが、通常の環境では言語自体がこれをサポートしていません。



この制限を回避する自然な方法は、値の代わりにポインターを渡すことです（参照渡し）。 Zigは別の戦略であるスライスを使用します。 スライスは、長さが付加されたポインターであり、境界に収まるかどうかをチェックします。 関数シグネチャの構文は次のようになります。

 fn bf(src: []const u8, mem: []u8) void { ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

関数を呼び出すと、次のようになります。

 bf(src, mem[0..mem.len]);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

配列の長さを参照するだけで上限を定義したことに注意してください。 そのような場合には、表記の省略形があります。

 bf(src, mem[0..]);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これで、bf（）関数を直接テストするテストの作成を開始できます。 今のところ、ファイルの最後にテスト機能を追加します...

 test "+" { var mem = []u8{0}; const src = "+++"; bf(src, mem[0..]); assert(mem[0] == 3); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

mem配列を1バイトから取得し、次に何が起こるかを確認します（バイトは3回インクリメントされます）。 うまくいく！

 Test 1/1 +...OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「-」は同じ方法でチェックされます。

 test "-" { var mem = []u8{0}; const src = "---"; bf(src, mem[0..]); assert(mem[0] == 253); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

動作しません！ 0から1を減算しようとすると、...

 Test 2/2 -...integer overflow
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

memは符号なしバイトの配列であり、0から1を引くとオーバーフローが発生します。 繰り返しになりますが、Zigは私が欲しいものを明示的に宣言させます。 この場合、私はオーバーフローについて心配する必要はありません。実際、私たちはBrainfuckの仕様に従ってモジュラー演算を扱っているので、オーバーフローが起こることを望みます。 つまり、数値0のセルをデクリメントすると255が得られ、255の増分で0が得られます。



Zigには、保証された「ラッピング」のセマンティクスを提供するいくつかの補助的な算術演算があります。

 '+' => mem[memptr] +%= 1, '-' => mem[memptr] -%= 1,
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これにより、オーバーフローの問題全体が解決され、期待どおりに動作します。



<and>をテストするために、小さな配列をナビゲートし、インクリメントされたセルの値を確認します。

 test ">" { var mem = []u8{0} ** 5; const src = ">>>+++"; bf(src, mem[0..]); assert(mem[3] == 3); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして...

 test "<" { var mem = []u8{0} ** 5; const src = ">>>+++<++<+"; bf(src, mem[0..]); assert(mem[3] == 3); assert(mem[2] == 2); assert(mem[1] == 1); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

後者の場合、...を使用して静的配列と結果を直接比較できます...

 const mem = std.mem;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

すでにstdをインポートしていることを思い出してください。 以下の例では、この名前空間でmem.eqlを使用しています。

 test "<" { var storage = []u8{0} ** 5; const src = ">>>+++<++<+"; bf(src, storage[0..]); assert(mem.eql(u8, storage, []u8{ 0, 1, 2, 3, 0 })); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

...そして、文字列リテラルを思い出してください。これらはzigのu8配列であり、16進リテラルを入れることができます。 次のコードも同じように機能します！

 assert(mem.eql(u8, storage, "\x00\x01\x02\x03\x00"));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「。」を追加してください！ ポインタが指すセルのバイト値を文字として単に出力します。 現在warnを使用していますが、後でstdoutに置き換えます。 これは概念的には簡単ですが、実装では多少混乱します。 後でやります！

 '.' => warn("{c}", storage[memptr]),
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

サイクル

[および]-魔法はここから始まります....



[-現在のセルの値がゼロの場合、コードを実行せずに閉じ括弧へのステップをスキップします。

]-現在のセルの値がゼロでない場合、開き括弧に戻り、コードを再度実行します。



今回はテストから始めますが、一緒にテストします（明らかに、個別にテストするのは意味がありません）。 最初のテストケース-ストレージ[2]セルは空である必要がありますが、開始するとループが増加します。

 test "[] skips execution and exits" { var storage = []u8{0} ** 3; const src = "+++++>[>+++++<-]"; bf(src, storage[0..]); assert(storage[0] == 5); assert(storage[1] == 0); assert(storage[2] == 0); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

switchステートメントの空白を作成します。

 '[' => if (storage[memptr] == 0) { }, ']' => if (storage[memptr] == 0) { },
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今何をしますか？ 素朴なアプローチを使用できます。 srcポインタを見つけるまでインクリメントします]。 しかし、私はこのためにジグでforループを使用することはできません。これは、コレクションを反復するためだけに作成されたもので、要素を失うことはありません。 ここで適切な構成は次のとおりです。



だった：

 var memptr: u16 = 0; for (src) |c| { switch(c) { ... } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

なった...

 var memptr: u16 = 0; var srcptr: u16 = 0; while (srcptr < src.len) { switch(src[srcptr]) { ... } srcptr += 1; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これで、ブロックの中央でsrcptrポインターを再割り当てできます。これを行います。

 '[' => if (storage[memptr] == 0) { while (src[srcptr] != ']') srcptr += 1; },
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これは、「[]はコードの実行をスキップして終了する」というテストを満たします。

これは、「[]が実行をスキップして終了する」というテストを満たしますが、完全に信頼できるわけではありませんが、後で説明します。



閉じ括弧についてはどうですか？ 私はそれを単に類推によって書けると信じています：

 test "[] executes and exits" { var storage = []u8{0} ** 2; const src = "+++++[>+++++<-]"; bf(src, storage[0..]); assert(storage[0] == 0); assert(storage[1] == 25); } ']' => if (storage[memptr] != 0) { while (src[srcptr] != '[') srcptr -= 1; },
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

あなたは何が起こるかを見ることができます... 2つのブラケットを持つ素朴な解決策は致命的な欠陥を持ち、ネストされたループで完全に壊れます。 以下を考慮してください。

 ++>[>++[-]++<-]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

結果は{2、0}になりますが、最初の開き括弧は単純に愚かに最初の閉じ括弧に移動し、すべてが混乱します。 同じレベルのネストで、次の閉じ括弧にジャンプする必要があります。 深度カウンターを追加して、ラインに沿って前進するにつれて追跡するのは簡単です。 私たちは両方向でそれを行います：

 '[' => if (storage[memptr] == 0) { var depth:u16 = 1; srcptr += 1; while (depth > 0) { srcptr += 1; switch(src[srcptr]) { '[' => depth += 1, ']' => depth -= 1, else => {} } } }, ']' => if (storage[memptr] != 0) { var depth:u16 = 1; srcptr -= 1; while (depth > 0) { srcptr -= 1; switch(src[srcptr]) { '[' => depth -= 1, ']' => depth += 1, else => {} } } },
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

および関連するテスト：両方のテストのsrcには内部ループが含まれていることに注意してください。

 test "[] skips execution with internal braces and exits" { var storage = []u8{0} ** 2; const src = "++>[>++[-]++<-]"; try bf(src, storage[0..]); assert(storage[0] == 2); assert(storage[1] == 0); } test "[] executes with internal braces and exits" { var storage = []u8{0} ** 2; const src = "++[>++[-]++<-]"; try bf(src, storage[0..]); assert(storage[0] == 0); assert(storage[1] == 2); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

別に、[-]に注意してください-「このセルをゼロ」を意味するBrainfuckのイディオム。 セルが最初にどの値を持っていたかは関係なく、0に達するまでデクリメントされ、実行が続行されます。

不運な道

bfのプログラムが壊れる可能性を期待していませんでした。 間違った入力プログラムをインタープリターに送信するとどうなりますか？ たとえば、単に[閉じかっこ、または<なしで、すぐにメモリ配列を超えますか？ （メモリポインタをラップすることはできますが、これをエラーと見なすことをお勧めします）。



少し先を見て、コードのすべての違いを説明します。 bfインタープリター関数を別のファイルに配置し、seekBackおよびseekForward機能を独自の小さな関数に配置します。

 const warn = @import("std").debug.warn; const sub = @import("std").math.sub; fn seekBack(src: []const u8, srcptr: u16) !u16 { var depth:u16 = 1; var ptr: u16 = srcptr; while (depth > 0) { ptr = sub(u16, ptr, 1) catch return error.OutOfBounds; switch(src[ptr]) { '[' => depth -= 1, ']' => depth += 1, else => {} } } return ptr; } fn seekForward(src: []const u8, srcptr: u16) !u16 { var depth:u16 = 1; var ptr: u16 = srcptr; while (depth > 0) { ptr += 1; if (ptr >= src.len) return error.OutOfBounds; switch(src[ptr]) { '[' => depth += 1, ']' => depth -= 1, else => {} } } return ptr; } pub fn bf(src: []const u8, storage: []u8) !void { var memptr: u16 = 0; var srcptr: u16 = 0; while (srcptr < src.len) { switch(src[srcptr]) { '+' => storage[memptr] +%= 1, '-' => storage[memptr] -%= 1, '>' => memptr += 1, '<' => memptr -= 1, '[' => if (storage[memptr] == 0) srcptr = try seekForward(src, srcptr), ']' => if (storage[memptr] != 0) srcptr = try seekBack(src, srcptr), '.' => warn("{c}", storage[memptr]), else => {} } srcptr += 1; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これにより、スイッチは読みやすくなり、seekForwardとseekBackの外観と動作は非常に似ており、私はそれらをよりスマートでコンパクトなものにリファクタリングしたいと思いましたが、最終的には異なることをしてエラーを処理しますまた、さまざまな方法で。 コピーと調整が簡単なので、より明確になります。 また、おそらく次の投稿のいずれかで、ある時点でseekForwardを調整します。



重要なものを追加しました！ 3つの関数がすべて型を返すようになりました！..これは、以前はtype％T（エラー結合）だったものの新しい構文です。 これは、関数が特定のタイプまたはエラーを返すことができることを意味します。 そのような関数を呼び出そうとすると、関数を呼び出す前にtryを使用する必要があります。これは、エラーが発生した場合に呼び出しスタックにエラーをスローするか、catchを使用します。

 const x = functionCall() catch {}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

catchブロックでエラーを処理する場所。 書いたように、catchはエラーを飲み込む可能性があります。 これは悪い習慣ですが、ここではZigによって明示的に行われます。 空のブロックでエラーをキャッチすると、エラーが発生する可能性があるとは思わないか、エラーを処理する必要がないと断言します。 実際には、TODOのようなものになる可能性があります。実際、明示的にすることも非常に簡単です。

 const x = functionCall() catch { @panic("TODO") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このようなケースは本番コードでは決して起こらないことを思い出してください。 自分が何をしているかを知っていることをコンパイラーに通知しています。 エラーが発生する可能性がある場合、エラー処理を追加する必要があります。



それで、seekBackまたはseekForwardから返されるエラーは何ですか？



seekBackの場合：

 ptr = sub(u16, ptr, 1) catch return error.OutOfBounds;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

デクリメントポインターを置き換えて、std libのサブ関数を使用します。この関数は、オーバーフローが発生した場合にオーバーフローエラーをスローします。 このエラーをキャッチして、代わりにOutOfBoundsエラーを返したいので、それを使用してここで作成します。

エラーZigは基本的に、エラーを使用するときにコンパイラーによって生成されるエラーコードの配列です。 これらは一意であることが保証されており、switchブロックの値として使用できます。

ここでOutOfBoundsを使用したいのは、意味的に、メモリポインタが0未満になった場合、ランタイムに割り当てたメモリ領域を超えるように要求するためです。



同様に、seekForward関数で：

 if (ptr >= src.len) return error.OutOfBounds;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、ポインターがsrc.lenより大きい場合、ここでエラーをキャッチし、同じエラーを返します。



呼び出すとき：

 '[' => if (storage[memptr] == 0) srcptr = try seekForward(src, srcptr), ']' => if (storage[memptr] != 0) srcptr = try seekBack(src, srcptr),
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これらの関数を呼び出そうとします。 正常に呼び出された場合、正しく実行され、srcptrが返されます。 失敗した場合、tryは関数を終了し、bf関数全体が呼び出された場所にエラーを返します。



呼び出しはメインからの場合があります！

 const bf = @import("./bf.zig").bf; // yes, hello const hello_world = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."; pub fn main() void { storage = []u8{0} ** 30000; bf(hello_world, storage[0..]) catch {}; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここでこのエラーを飲み込みますが、そうすべきではありませんが、ジグがどのように簡単にエラーを呼び出しスタックに渡すことができるかについての重要なポイントに注意してください。 エラーのすべてのケースをチェックするのは呼び出し側関数の責任ではありませんが、コンパイラーはtryで呼び出しに失敗する可能性のある各関数を強制します。 エラーが無視されても、これは常に行われなければなりません！

新しいtry / catch構文は、人々がそれほど嫌う%%や％のような多くの呪文を排除します。

今、私は8人中7人のBrainfuckキャラクターを実装しました。これは「意味のある」プログラムを実行するのに十分です。

意味のあるプログラム

プログラムは次のとおりです。

 //   ,   const fib = "++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++>++++++++++++++++>>+<<[>>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[<+>-]>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<.>.>>[>>+<<-]>[>+<<+>-]>[<+>-]<<<-]<<++...";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

起動...

 pub fn main() void { storage = []u8{0} ** 30000; bf(fib, storage[0..]) catch {}; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

出来上がり！

 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 121, 98, 219,
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

フィボナッチシリーズのことを考えるたびに思い出が1つ返ってきます... 80年代のPBS（公共放送サービス、アメリカの非営利テレビ放送サービス）番組でそれを知りました。 忘れられると思いましたが、 Youtubeは素晴らしいものです。

どうすればこれを改善できますか？

私はすでにいくつかのTODOをほのめかしました。 出力にstderrを使用するべきではありません。 stdoutを使用したい。



インタープリターを開くたびに、stdoutでストリームを開き、印刷します。

 const io = std.io; ... pub fn bf(src: []const u8, storage: []u8) !void { const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); ... '.' => stdout.print("{c}", storage[memptr]) catch unreachable, ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで何が起こっていますか？私はio.getStdOut（）を呼び出します。これはエラーを生成する可能性があります（また、catch unreachableでエラーを明示的に飲み込みます-この関数がエラーを返すと、プログラムはクラッシュします！）。ストリームを初期化し、ポインターを取得し、printを呼び出して書き込み可能な出力ストリームとして初期化します。 printは、warnのようなフォーマットされた文字列を受け入れるため、置換は直接です。 printでもエラーが発生する可能性があり、これらのエラーも飲み込みます。



正しく記述されたプログラムでは、stdoutを開く際の潜在的なエラーと、stdoutに書き込もうとする際に発生する可能性のあるエラーを考慮する必要があります。 Zigを使用すると、無視していることがわかっている限り、これらのエラーを非常に簡単に無視できます。



プロトタイプをリリースにしたいと決めた場合はどうなりますか？コーヒーを飲みながら座ってエラーを処理するというありがたい仕事をします。何十年もの経験と知識に基づいて、エラーの可能性のあるすべてのケースをリストし、どのように処理できますか。しかし、私が何十年もの経験と知識を持っていない場合はどうなりますか？大丈夫、Zigがやる！



強力なこと、エラー出力を示したい！

 const bf = @import("./bf.zig").bf; const warn = @import("std").debug.warn; const serpinsky = "++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[ -<<<[ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<< ]>.>+[>>]>+ ] "; pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch unreachable; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

bfは返されるためエラーを生成することがあることを知っています！メイン関数の呼び出し側でこのエラーを飲み込みます。運命を受け入れて正しいことをする準備ができたら、次のようなエラーをキャッチできます。

 const bf = @import("./bf.zig").bf; const warn = @import("std").debug.warn; const serpinsky = "++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[ -<<<[ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<< ]>.>+[>>]>+ ] "; pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch |err| switch (err) { }; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

コンパイラは今私の友人です！

 /Users/jfo/code/zigfuck/main.zig:7:46: error: error.OutOfBounds not handled in switch shell returned 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このエラーは、bfおよび補助関数から発生したため、おなじみのはずです！しかし、bfで飲み込んだstdoutによって生成されたエラーを見ると想像してみましょう。それらを飲み込む代わりに、tryを使用してチェーンを押し上げる必要があります。キャッチせずにエラーを生成する関数の呼び出しを使用して、tryを使用することを思い出してください。tryは、エラーが発生したときに関数を終了し、呼び出し関数に潜在的なエラーの処理を提供します。



したがって、代わりに：

 const io = std.io; ... pub fn bf(src: []const u8, storage: []u8) !void { const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); ... '.' => stdout.print("{c}", storage[memptr]) catch unreachable, ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

私たちはやる：

 const io = std.io; ... pub fn bf(src: []const u8, storage: []u8) !void { const stdout = &(io.FileOutStream.init(&(try io.getStdOut())).stream); ... '.' => try stdout.print("{c}", storage[memptr]), ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

コンパイルします：

 const bf = @import("./bf.zig").bf; const warn = @import("std").debug.warn; const serpinsky = "++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[ -<<<[ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<< ]>.>+[>>]>+ ] "; pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch |err| switch (err) { }; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

関数を呼び出すことで取得できるすべてのエラーのリストを取得します！

 /Users/jfo/code/zigfuck/main.zig:7:46: error: error.SystemResources not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.OperationAborted not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.IoPending not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.BrokenPipe not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.Unexpected not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.WouldBlock not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.FileClosed not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.DestinationAddressRequired not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.DiskQuota not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.FileTooBig not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.InputOutput not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.NoSpaceLeft not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.AccessDenied not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.OutOfBounds not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.NoStdHandles not handled in switch shell returned 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Zigを使用すると、これらのエラーを必要に応じて処理できるようになります。エラー値に基づいて切り替えを行い、必要であればケースを処理し、スキップしたい場合はスキップします。

 pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch |err| switch (err) { error.OutOfBounds => @panic("Out Of Bounds!"), else => @panic("IO error") }; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

厳密に言えば、これはまだ正しいエラー処理ではありませんが、すべての種類のエラーケースを呼び出し関数に報告することにより、Zigがいかにスマートであるかを実証したいだけです！そして、エラーが発生すると、スタックトレースの代わりにエラートレースを取得します！かっこいい！

藤堂

インタープリターを使用してさまざまな改善を行うことができます！もちろん、実際にすべてのエラーを正しく処理する必要があります。また、brainfuckではgetc関数として機能し、実行時にプログラムにデータを入力できる「、」演算子を実装する必要があります。また、ハードコードされたbfソースコードを使用する代わりに、ソースファイルをバッファに読み込んで解釈できるようにする必要があります。厳密には必要ではない改善もいくつかありますが、Zigの機能の一部を示す場合があります。投稿の最後にそれらをすべてダンプするのではなく、それらを部分に分割し、将来の投稿で公開します。

おわりに

この半完成のミニチュアプロジェクトが、Zigコードがどのように見え、何に使用できるかについての洞察を与えてくれることを願っています。 Zigはスイスのナイフではありません。すべてに最適なツールではありません。特定のことに焦点を合わせており、CまたはC ++の代わりにまたは一緒に使用できる実用的なシステム言語であることに焦点を当てています。これにより、メモリ使用量、メモリ管理、およびエラー処理に慎重にアプローチしました。リソースが限られている環境では、これは便利な機能であり、バグではありません。 Zigは決定論的であり、あいまいさはなく、従来は困難であった環境で信頼性の高いコードの記述を促進しようとします。



Zigの構文と機能のごく一部を説明しましたが、バージョン0.2.0以降の言語には多くの興味深い変更があります！私が書いたコードはすべてデバッグモードでコンパイルされます。これはセキュリティチェックに最適で、コンパイル時間を短縮して反復を高速化するのに最適です。 --release-fastモードと--release-safeモードがあり、今後さらに多くのモードが追加されます。これらのモードの違いと説明については、こちらをご覧ください。



Zigの開発のスピードと方向には常に驚かされます。多くはまだ動いていますが、バージョン1.0.0のリリースまではそうであり、Zigを試してみることにしたのであれば、たくさんの良いアイデアがあることを覚えておいてください。



試してみて、質問があればいつでもfreenodeで#zigに参加してください。