docs(zig): add Zig 0.14 language syntax reference

- document comment types, variable declarations, and data types
- explain control flow constructs: if, while, for, switch
- cover functions, error handling, and core constructs (defer, unreachable, struct, enum, union, opaque)
- include list of Zig language keywords

Author: jinzhongjia

zig_0_14.md

@@ -0,0 +1,288 @@
+## Zig Language Syntax
+
+### Comments
+
+Zig supports three types of comments:
+
+*   **Normal Comments**: Start with `//` and continue to the end of the line. They are ignored by the compiler.
+    ```zig
+    // This is a normal comment.
+    ```
+*   **Doc Comments**: Start with `///` and document the declaration that immediately follows.
+    ```zig
+    /// This is a documentation comment for the MyStruct struct.
+    const MyStruct = struct {
+        /// This is a doc comment for the field `x`.
+        x: i32,
+    };
+    ```
+*   **Top-Level Doc Comments**: Start with `//!` and document the current module. They must be at the beginning of a file.
+    ```zig
+    //! This is a top-level doc comment for the entire file.
+    ```
+
+### Variable Declarations
+
+Variables are declared using the `const` and `var` keywords.
+
+*   **`const`**: Declares a constant (immutable) variable.
+    ```zig
+    const x: i32 = 10;
+    const y = 20; // Type is inferred
+    ```
+*   **`var`**: Declares a mutable variable.
+    ```zig
+    var x: i32 = 10;
+    var y = 20; // Type is inferred
+    ```
+*   **`undefined`**: Used to initialize a variable without giving it a specific value.
+    ```zig
+    var x: i32 = undefined;
+    ```
+*   **`threadlocal`**: Declares a thread-local variable.
+    ```zig
+    threadlocal var x: i32 = 0;
+    ```
+
+### Data Types
+
+#### Primitive Types
+
+| Type           | Description                               |
+| :------------- | :---------------------------------------- |
+| `iN`, `uN`     | Signed and unsigned integers of N bits.   |
+| `isize`, `usize` | Signed and unsigned pointer-sized integers. |
+| `f16`, `f32`, `f64`, `f80`, `f128` | Floating-point numbers. |
+| `bool`         | `true` or `false`.                        |
+| `void`         | Represents the absence of a value.        |
+| `anyerror`     | A generic error type.                     |
+| `anyopaque`    | Used for type-erased pointers.            |
+| `noreturn`     | Indicates a function that does not return. |
+| `type`         | The type of a type.                       |
+| `comptime_int` | The type of an integer literal.           |
+| `comptime_float`| The type of a float literal.              |
+
+#### Literals
+
+*   **Integer Literals**:
+    ```zig
+    const decimal = 1234;
+    const hex = 0xff;
+    const octal = 0o755;
+    const binary = 0b1100;
+    ```
+*   **Float Literals**:
+    ```zig
+    const float1 = 1.23;
+    const float2 = 1.23e4;
+    ```
+*   **String Literals**:
+    ```zig
+    const str = "hello"; // Type is *const [5:0]u8
+    ```
+*   **Character Literals**:
+    ```zig
+    const char = 'a'; // Type is comptime_int
+    ```
+
+### Control Flow
+
+#### `if`
+
+The `if` statement executes a block of code if a condition is true.
+
+```zig
+if (x > 10) {
+    // ...
+} else if (x > 5) {
+    // ...
+} else {
+    // ...
+}
+```
+
+`if` can also capture the payload of an optional type.
+
+```zig
+if (optional_value) |value| {
+    // use value
+}
+```
+
+#### `while`
+
+The `while` loop repeatedly executes a block of code as long as a condition is true.
+
+```zig
+while (x < 10) {
+    x += 1;
+}
+```
+
+`while` can also be used with optionals and error unions.
+
+```zig
+while (optional_value) |value| {
+    // use value
+}
+
+while (error_union) |value| {
+    // use value
+} else |err| {
+    // handle error
+}
+```
+
+#### `for`
+
+The `for` loop iterates over the elements of an array, slice, or tuple.
+
+```zig
+const items = [_]i32{ 1, 2, 3 };
+for (items) |item| {
+    // use item
+}
+
+// With index
+for (items, 0..) |item, i| {
+    // use item and i
+}
+```
+
+#### `switch`
+
+The `switch` statement provides a way to execute different code blocks based on the value of an expression.
+
+```zig
+switch (value) {
+    1 => { /* ... */ },
+    2 => { /* ... */ },
+    else => { /* ... */ },
+}
+```
+
+`switch` must be exhaustive.
+
+### Functions
+
+Functions are declared with the `fn` keyword.
+
+```zig
+fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+```
+
+*   **`pub`**: Makes a function visible outside the current module.
+*   **`inline`**: Suggests to the compiler that the function should be inlined.
+*   **`noreturn`**: Specifies that the function will not return.
+
+### Error Handling
+
+Zig has a unique approach to error handling using error sets and error unions.
+
+*   **`error`**: A set of possible error values.
+    ```zig
+    const MyError = error{
+        InvalidValue,
+        OutOfMemory,
+    };
+    ```
+*   **Error Union**: A type that can hold either a value or an error.
+    ```zig
+    fn doSomething() !i32 {
+        if (something_wrong) {
+            return error.InvalidValue;
+        }
+        return 42;
+    }
+    ```
+    The `!` in `!i32` is a shorthand for `anyerror!i32`.
+
+*   **`try`**: Unwraps a value from an error union. If the value is an error, the function returns the error.
+    ```zig
+    const value = try doSomething();
+    ```
+*   **`catch`**: Unwraps a value from an error union, with a fallback value or block for the error case.
+    ```zig
+    const value = doSomething() catch 0;
+
+    const value2 = doSomething() catch |err| {
+        // handle error
+        return 0;
+    };
+    ```
+*   **`errdefer`**: Executes a statement when the function returns with an error.
+    ```zig
+    errdefer cleanup();
+    ```
+
+### Other Core Constructs
+
+#### `defer`
+
+Executes a statement at the end of the current block, regardless of how the block is exited.
+
+```zig
+defer file.close();
+```
+
+#### `unreachable`
+
+Asserts that a piece of code is never executed.
+
+```zig
+if (value > 10) {
+    // ...
+} else {
+    unreachable;
+}
+```
+
+#### `struct`
+
+A collection of named fields.
+
+```zig
+const Point = struct {
+    x: i32,
+    y: i32,
+};
+```
+
+#### `enum`
+
+A type with a fixed set of named values.
+
+```zig
+const Color = enum {
+    red,
+    green,
+    blue,
+};
+```
+
+#### `union`
+
+A type that can hold one of several types at a time.
+
+```zig
+const MyUnion = union {
+    integer: i32,
+    float: f32,
+};
+```
+
+#### `opaque`
+
+An opaque type is a type whose layout and size is unknown.
+
+```zig
+const MyOpaqueType = opaque {};
+```
+
+### Keywords
+
+Here is a list of keywords found in the Zig language reference:
+
+`addrspace`, `align`, `allowzero`, `and`, `anyframe`, `anyopaque`, `asm`, `async`, `await`, `break`, `callconv`, `catch`, `comptime`, `const`, `continue`, `defer`, `else`, `enum`, `errdefer`, `error`, `export`, `extern`, `false`, `fn`, `for`, `if`, `inline`, `noalias`, `nosuspend`, `null`, `opaque`, `or`, `orelse`, `packed`, `promise`, `pub`, `resume`, `return`, `linksection`, `struct`, `suspend`, `switch`, `test`, `threadlocal`, `true`, `try`, `type`, `union`, `unreachable`, `usingnamespace`, `var`, `volatile`, `while`