@mirascript/help 0.1.44 → 0.1.46

package/dist/index.d.ts

@@ -18,11 +18,13 @@ export declare const KEYWORDS: {
   readonly "let": string;
   readonly "loop": string;
   readonly "match": string;
+  readonly "mod": string;
   readonly "mut": string;
   readonly "nan": string;
   readonly "nil": string;
   readonly "not": string;
   readonly "or": string;
+  readonly "pub": string;
   readonly "return": string;
   readonly "true": string;
   readonly "type": string;

package/dist/index.js

@@ -13,17 +13,19 @@ export const KEYWORDS = Object.freeze({
   "for": "`for` 用于遍历可迭代对象。\n\n---\n\n遍历一个范围：\n\n```mira\nlet mut sum = 0;\nfor i in 1..3 { // 或者 1..<4\n  sum += i;\n}\n// sum == 6\n```\n\n---\n\n遍历一个数组：\n\n```mira\nlet arr = [10, 20, 30];\nlet mut sum = 0;\nfor value in arr {\n  sum += value;\n}\n// sum == 60\n```\n\n---\n\n遍历一个记录：\n\n```mira\nlet record = (a: 1, b: 2, c: 3);\nlet mut sum = 0;\nfor key in record {\n  sum += record[key];\n}\n// sum == 6\n```\n",
   "global": "`global` 关键字用于读取全局变量或判断某个全局变量是否存在。\n\n---\n\n当变量名与局部变量冲突时，可以使用 `global` 关键字来访问全局变量。\n\n```mira\nlet some_name = 'shadow';\nsome_name; // 访问局部变量 'some_name'\nglobal.some_name; // 访问全局变量 'some_name'\n```\n\n---\n\n动态判断和访问全局变量：\n\n```mira\nfn get_global(name, fallback) {\n  if name in global {\n    global[name]\n  } else {\n    fallback\n  }\n}\n```\n",
   "if": "`if` 用于 `if` 表达式或 `match` 表达式的守卫条件。\n\n---\n\n`if` 表达式根据条件选择分支。条件必须是 `boolean`。\n\n```mira\nlet x = if 1 > 0 { \"pos\" } else { \"neg\" };\n```\n\n---\n\n使用 `else if` 添加多个条件分支：\n\n```mira\nlet x = if 1 > 2 {\n  \"greater\"\n} else if 1 == 2 {\n  \"equal\"\n} else {\n  \"less\"\n};\n```\n\n---\n\n在 `match` 表达式中使用 `if` 作为守卫条件：\n\n```mira\nlet num = 10;\nlet result = match num {\n  case n if n % 2 == 0 { \"even\" }\n  case n { \"odd\" }\n};\n// result 的值是 \"even\"\n```\n",
-  "in": "`in` 用于“包含/存在”判断，以及 `for` 循环。\n\n---\n\n对于 `array` 类型，`in` 用于判断某个元素是否在数组中存在：\n\n```mira\nfn is_spring(month) {\n  month in [3, 4, 5]\n}\n```\n\n---\n\n对于 `record` / `module` / `extern` 类型，`in` 用于判断某个键是否在容器中存在：\n\n```mira\nlet record = (a: 1, b: 2, c: 3);\nlet a_exists = 'a' in record; // true\n```\n\n---\n\n也可与 `global` 关键字结合使用，判断全局变量是否存在：\n\n```mira\nif 'my_global' in global {\n  my_global += 1;\n}\n```\n\n---\n\n同时，`for` 循环也使用 `in`：\n\n```mira\nfor i in 1..3 {\n  // i: 1, 2, 3\n}\n```\n",
+  "in": "`in` 用于“包含/存在”判断，以及 `for` 循环。\n\n---\n\n对于 `array` 类型，`in` 用于判断某个元素是否在数组中存在：\n\n```mira\nfn is_spring(month) {\n  month in [3, 4, 5]\n}\n```\n\n---\n\n对于 `record` / `module` / `extern` 类型，`in` 用于判断某个键是否在容器中存在：\n\n```mira\nlet record = (a: 1, b: 2, c: 3);\nlet a_exists = 'a' in record; // true\n```\n\n---\n\n也可与 `global` 关键字结合使用，判断全局变量是否存在：\n\n```mira\nif 'my_global' in global {\n  debug_print('my_global exists');\n}\n```\n\n---\n\n同时，`for` 循环也使用 `in`：\n\n```mira\nfor i in 1..3 {\n  // i: 1, 2, 3\n}\n```\n",
   "inf": "`inf` 是正无穷大的 `number` 常量。\n\n```mira\ninf > 1e100; // true\n-inf < 0;    // true\n```\n",
   "is": "`is` 用于模式匹配：`value is pattern`，结果为 `boolean`。\n\n```mira\n1 is 1;        // true\n1 is > 0;      // true\n(a: 1) is (a: x); // true（并绑定 x）\n```\n",
   "let": "`let` 用于声明局部变量。\n\n```mira\nlet x = 1;\nlet y = x + 2;\nlet mut z = y * 3;\n```\n",
   "loop": "`loop` 创建一个无限循环，通常配合 `break` 退出。\n\n```mira\nlet mut i = 0;\nloop {\n  i += 1;\n  if i >= 3 { break; }\n}\n```\n",
   "match": "`match` 表达式对一个值进行分支匹配，由多个 `case` 组成。\n\n```mira\nfn classify {\n  match it {\n    case (0, 0) { \"Origin\" }\n    case (x, 0) if x > 0 { \"Positive X-Axis (x=$x)\" }\n    case (x, 0) if x < 0 { \"Negative X-Axis (x=$x)\" }\n    case (0, y) { \"Y-Axis (y=$y)\" }\n    case (x, y) { \"Somewhere else (x=$x, y=$y)\" }\n    case _ { \"Not a point\" }\n  }\n}\n```\n",
+  "mod": "`mod` 用于声明一个模块。\n\n```mira\nmod counter {\n  pub let mut value = 0;\n  pub fn inc(){\n    value += 1;\n  }\n}\n\ndebug_print(counter.value); // 0\ncounter.inc();\ndebug_print(counter.value); // 1\n```\n",
   "mut": "`mut` 用于声明可变变量。\n\n---\n\n使用 `let` 语句时声明一个可变变量：\n\n```mira\nlet mut x = 1;\nx += 2;\n// x == 3\n```\n\n---\n\n在模式匹配中声明一个可变绑定：\n\n```mira\nlet (mut a, b) = (1, 2);\na += 10;\n// b += 10; // 这行代码会报错，因为 b 是不可变的\n```\n",
   "nan": "`nan` 是一个特殊的 `number` 值（Not a Number）。它与任何值都不相等（包括它自己）。\n\n```mira\nnan == nan; // false\nnan =~ nan; // false\n```\n",
   "nil": "`nil` 表示“空值”。当访问不存在的字段、对 `nil` 进行空安全链式调用等场景时，结果也会是 `nil`。\n\n```mira\nlet x = nil;\nlet y = x ?? 0;     // 0\nlet z = x.anything; // nil（空安全访问）\n```\n",
   "not": "`not` 用于在模式匹配中取反一个模式，也可以作为 `!` 运算符的替代写法。\n\n---\n\n逻辑非模式：\n\n```mira\nfn is_not_weekend(day) {\n  day is not 6 and not 7\n}\n```\n\n---\n\n逻辑非运算符：\n\n```mira\nfn is_minor(age) {\n  // 等同于 !(age >= 18)\n  not (age >= 18)\n}\n```\n",
   "or": "`or` 用于在模式匹配中组合多个模式，也可以作为 `||` 运算符的替代写法。\n\n---\n\n逻辑或模式：\n\n```mira\nfn is_weekend(day) {\n  day is 6 or 7\n}\n```\n\n---\n\n逻辑或运算符：\n\n```mira\nfn is_superuser(role) {\n  // 等同于 role == \"admin\" || role == \"superuser\"\n  role == \"admin\" or role == \"superuser\"\n}\n```\n",
+  "pub": "`pub` 用于将模块内的声明导出。\n\n```mira\nmod counter {\n  pub let mut value = 0;\n  pub fn inc(){\n    value += 1;\n  }\n}\n\ndebug_print(counter.value); // 0\ncounter.inc();\ndebug_print(counter.value); // 1\n```\n",
   "return": "`return` 用于从函数中返回值。\n\n```mira\nfn abs {\n  if it < 0 { return -it; }\n  return it;\n}\n```\n",
   "true": "`true` 是布尔字面量，表示逻辑真。\n",
   "type": "`type` 用于获得值的类型名字符串。\n\n```mira\ntype(1);       // \"number\"\nnil::type();   // \"nil\"（扩展调用写法）\n```\n",
@@ -46,7 +48,7 @@ export const OPERATORS = Object.freeze({
   ",": "`,` 用于分隔参数、数组元素、记录字段等。\n\n```mira\nlet arr = [1, 2, 3];\nlet r = (a: 1, b: 2);\n\nfn f(a, b, c) { a + b + c }\nf(1, 2, 3);\n```\n",
   ".": "`.` 用于成员访问。\n\n```mira\nlet r = (a: 1);\nr.a; // 1\nr.b; // nil\n\nlet arr = [10, 20];\narr.0; // 10\narr.2; // nil\n```\n",
   "==": "使用 `==` 运算符可以比较两个值是否严格相等。\n\n---\n\n对于原始值，如果它们的类型和值都相同，则认为它们相等。\n\n```mira\n5 == 5;            // true\n\"hello\" == \"hello\"; // true\ntrue == true;      // true\n5 == \"5\";         // false\n```\n\n特别地，对于 `number` 类型的值 `nan`，它与任何值都不相等，包括它自己。\n\n```mira\nnan == nan; // false\n```\n\n---\n\n对于 `array` 和 `record`，只有他们的元素和属性都相等时，才认为它们相等。\n\n```mira\n[1, 2, 3] == [1, 2, 3]; // true\n(a: 1, b: 2) == (a: 1, b: 2); // true\n[1, 2, 3] == [1, 2, 4]; // false\n```\n\n---\n\n对于 `function` `module` 和 `extern`，只有它们引用的是同一个对象时，才认为它们相等。\n\n```mira\nlet fn1 = fn() { return 1; };\nlet fn2 = fn() { return 1; };\nfn1 == fn1; // true\nfn1 == fn2; // false\n```\n",
-  "!": "`!` 既可以作为前缀逻辑非，也可以作为后缀非空断言。\n\n---\n\n逻辑非：\n\n```mira\n!x // x 必须是 boolean\n```\n\n---\n\n非空断言：\n\n```mira\n\nlet x = nil;\nx!; // panic\n```\n",
+  "!": "`!` 既可以作为前缀逻辑非，也可以作为后缀非空断言。\n\n---\n\n逻辑非：\n\n```mira\n!x; // x 必须是 boolean\n```\n\n---\n\n非空断言：\n\n```mira\nlet x = nil;\nx!; // panic\n```\n",
   ">": "`>` 用于“大于”比较。\n\n```mira\n2 > 1;     // true\n\"b\" > \"a\"; // true\n```\n",
   ">=": "`>=` 用于“大于等于”比较。\n\n```mira\n2 >= 2; // true\n```\n",
   "..<": "`..<` 表示右开区间范围，包含起点，不包含终点。\n\n```mira\n[1..<3]; // [1, 2]\n\nlet arr = [10, 20, 30, 40];\narr[1..<3]; // [20, 30]\n```\n",
@@ -61,15 +63,15 @@ export const OPERATORS = Object.freeze({
   "!=": "`!=` 判断两个值是否不相等，等价于 `!(x == y)`。\n\n```mira\n1 != 2; // true\n1 != 1; // false\n```\n",
   "??": "`??` 是空合并，当左侧为 `nil` 时返回右侧，否则返回左侧。\n\n```mira\nnil ?? 1; // 1\n0 ?? 1;   // 0\n```\n",
   "??=": "`??=` 是空合并复合赋值，仅当左侧为 `nil` 时才会赋值右侧。\n\n```mira\nlet mut n = nil;\nn ??= 5;\n// n == 5\n\nn ??= 10;\n// n 仍然是 5\n```\n",
-  "(": "`( )` 用于分组表达式、函数调用参数列表，以及记录字面量。\n\n---\n\n分组表达式，控制计算顺序：\n\n```mira\nlet result = (1 + 2) * 3; // 先计算 1 + 2，然后乘以 3\n```\n\n---\n\n函数声明和调用：\n\n```mira\nfn add(a, b) { a + b }\nlet sum = add(1, 2);\n```\n\n---\n\n记录字面量：\n\n```mira\nlet record = (a: 1, b: 2);\nlet empty = (); // 空记录\n```\n\n---\n\n对于省略键名的单元素记录，必须添加逗号以区别于分组表达式。\n\n```mira\nlet single = (1,)\n```\n",
-  ")": "`( )` 用于分组表达式、函数调用参数列表，以及记录字面量。\n\n---\n\n分组表达式，控制计算顺序：\n\n```mira\nlet result = (1 + 2) * 3; // 先计算 1 + 2，然后乘以 3\n```\n\n---\n\n函数声明和调用：\n\n```mira\nfn add(a, b) { a + b }\nlet sum = add(1, 2);\n```\n\n---\n\n记录字面量：\n\n```mira\nlet record = (a: 1, b: 2);\nlet empty = (); // 空记录\n```\n\n---\n\n对于省略键名的单元素记录，必须添加逗号以区别于分组表达式。\n\n```mira\nlet single = (1,)\n```\n",
+  "(": "`( )` 用于分组表达式、函数调用参数列表，以及记录字面量。\n\n---\n\n分组表达式，控制计算顺序：\n\n```mira\nlet result = (1 + 2) * 3; // 先计算 1 + 2，然后乘以 3\n```\n\n---\n\n函数声明和调用：\n\n```mira\nfn add(a, b) { a + b }\nlet sum = add(1, 2);\n```\n\n---\n\n记录字面量：\n\n```mira\nlet record = (a: 1, b: 2);\nlet empty = (); // 空记录\n```\n\n---\n\n对于省略键名的单元素记录，必须添加逗号以区别于分组表达式。\n\n```mira\nlet single = (1,);\n```\n",
+  ")": "`( )` 用于分组表达式、函数调用参数列表，以及记录字面量。\n\n---\n\n分组表达式，控制计算顺序：\n\n```mira\nlet result = (1 + 2) * 3; // 先计算 1 + 2，然后乘以 3\n```\n\n---\n\n函数声明和调用：\n\n```mira\nfn add(a, b) { a + b }\nlet sum = add(1, 2);\n```\n\n---\n\n记录字面量：\n\n```mira\nlet record = (a: 1, b: 2);\nlet empty = (); // 空记录\n```\n\n---\n\n对于省略键名的单元素记录，必须添加逗号以区别于分组表达式。\n\n```mira\nlet single = (1,);\n```\n",
   "%": "`%` 用于取余。\n\n```mira\n5 % 2; // 1\n```\n",
   "%=": "`%=` 是复合赋值：`x %= y` 等价于 `x = x % y`。\n\n```mira\nlet mut x = 5;\nx %= 2;\n// x == 1\n```\n",
   "+": "`+` 用于加法（中缀）或一元正号（前缀）。\n\n```mira\n1 + 2; // 3\n+1;    // 1\n```\n",
   "+=": "`+=` 是复合赋值，`x += y` 等价于 `x = x + y`。\n\n```mira\nlet mut x = 1;\nx += 2;\n// x == 3\n```\n",
   "?": "`?` 用于条件表达式（三元表达式）：`cond ? thenExpr : elseExpr`。\n\n```mira\nfn sign { it > 0 ? 1 : it < 0 ? -1 : 0 }\n```\n",
   "?:": "`?:` 用于记录字面量的“可选字段”，当值为 `nil` 时省略该字段。\n\n```mira\n(a?: 1, b?: nil); // (a: 1)\n\n// 省略不会删除已经通过展开引入的同名字段\n(..(a: 1), a?: nil); // (a: 1)\n```\n",
-  ";": "`;` 用于结束语句。MiraScript 以表达式为主，但在多语句块中常用 `;` 分隔。\n\n```mira\nlet sum = {\n  let x = 1;\n  let y = 2;\n  x + y\n};\n```\n",
+  ";": "`;` 用于结束语句。MiraScript 以表达式为主，但在多语句块中使用 `;` 分隔。\n\n```mira\nlet sum = {\n  let x = 1;\n  let y = 2;\n  x + y\n};\n```\n",
   "/": "`/` 用于除法。\n\n```mira\n6 / 3; // 2\n```\n",
   "/=": "`/=` 是复合赋值，`x /= y` 等价于 `x = x / y`。\n\n```mira\nlet mut x = 6;\nx /= 3;\n// x == 2\n```\n",
   "..": "`..` 表示闭区间范围，或在数组/记录字面量及函数调用中表示展开。\n\n---\n\n表示数组字面量、切片和循环的范围：\n\n```mira\nlet arr = [1..3]; // arr = [1, 2, 3]\nlet slice = arr[0..1]; // slice = [1, 2]\n\nfor i in 1..3 {\n  // i 依次为 1, 2, 3\n}\n```\n\n---\n\n展开数组/记录或函数调用：\n\n```mira\nlet arr = [1, ..[2, 3]]; // arr = [1, 2, 3]\nlet rec1 = (a: 1, ..(b: 2, c: 3)); // rec1 = (a: 1, b: 2, c: 3)\n// 同名键以最后一个为准\nlet rec2 = (..(1, 2), ..(3, 4, 5)); // rec2 = (0: 3, 1: 4, 2: 5)\n\nlet result = sum(..[1, 2, 3]); // 等同于 sum(1, 2, 3)\n```\n",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirascript/help",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "author": "CloudPSS",
   "license": "MIT",
   "description": "Help documentation for Mirascript core language.",

package/scripts/build.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { load } from 'js-yaml';
 
 const packageRoot = path.resolve(import.meta.dirname, '..');
-const srcRoot = path.join(packageRoot, 'src');
+const srcRoot = path.join(packageRoot, '../../docs/references');
 const distRoot = path.join(packageRoot, 'dist');
 
 /**
@@ -86,8 +86,8 @@ async function loadDocsFromFolder(folder) {
         const relativePath = path.posix.join(folder, dirent.name);
         const markdown = await readMarkdown(relativePath);
         const { attributes, body } = splitFrontMatter(markdown, relativePath);
-        const { token, reserved } = attributes;
-        putItem({ token, body, reserved: Boolean(reserved), file: relativePath });
+        const { token, title, reserved } = attributes;
+        putItem({ token: token ?? title, body, reserved: Boolean(reserved), file: relativePath });
     }
 
     const seenToken = new Set();

package/src/keyword/and.md

@@ -1,26 +0,0 @@
----
-token: 'and'
----
-
-`and` 用于在模式匹配中组合多个模式，也可以作为 `&&` 运算符的替代写法。
-
----
-
-逻辑与模式：
-
-```mira
-fn is_month(month) {
-  month is >= 1 and <= 12
-}
-```
-
----
-
-逻辑与运算符：
-
-```mira
-fn is_adult(age) {
-  // 等同于 age >= 18 && age <= 65
-  age >= 18 and age <= 65
-}
-```

package/src/keyword/break.md

@@ -1,32 +0,0 @@
----
-token: 'break'
----
-
-`break` 用于提前退出 `for` / `while` / `loop`。
-
----
-
-基本用法
-
-```mira
-let mut i = 0;
-loop {
-  i += 1;
-  break;
-}
-```
-
----
-
-从循环中返回一个值
-
-```mira
-let mut i = 0;
-let result = loop {
-  i += 1;
-  if i == 10 {
-    break i * 2;
-  }
-};
-// result 的值是 20
-```

package/src/keyword/case.md

@@ -1,16 +0,0 @@
----
-token: 'case'
----
-
-`case` 是 `match` 表达式中的分支。
-
-```mira
-fn age_group(age) {
-  match age {
-    case 0..12 { "child"}
-    case 13..19 { "teenager" }
-    case 20..64 { "adult" }
-    case _ { "senior" }
-  }
-}
-```

package/src/keyword/const.md

@@ -1,10 +0,0 @@
----
-token: 'const'
----
-
-`const` 用于声明常量。常量名必须以 `@` 开头。
-
-```mira
-const @PI = 3.14159;
-// @PI = 0; // 错误：常量不可重新赋值
-```

package/src/keyword/continue.md

@@ -1,14 +0,0 @@
----
-token: 'continue'
----
-
-`continue` 用于跳过本次循环剩余部分，进入下一次循环。
-
-```mira
-let mut sum = 0;
-for i in 1..5 {
-  if i % 2 == 0 { continue; }
-  sum += i;
-}
-// sum == 1 + 3 + 5
-```

package/src/keyword/effect.md

@@ -1,6 +0,0 @@
----
-token: 'effect'
-reserved: true
----
-
-`effect` 是保留关键字。

package/src/keyword/else.md

@@ -1,32 +0,0 @@
----
-token: 'else'
----
-
-`else` 用于 `if` 表达式，也可用作 `while` 和 `for` 循环的可选分支。
-
----
-
-作为 `if` 表达式的分支
-
-```mira
-let x = if false { 1 } else { 2 }; // 2
-```
-
----
-
-作为循环的可选分支
-
-```mira
-let mut i = 0;
-let result = while i < 5 {
-  i += 1;
-  if i == 6 {
-    // 使用 break 语句提前退出循环，并返回一个值
-    break i * 2;
-  }
-} else {
-  // 当循环正常结束时执行
-  100
-};
-// result 的值是 100
-```

package/src/keyword/false.md

@@ -1,5 +0,0 @@
----
-token: 'false'
----
-
-`false` 是布尔字面量，表示逻辑假。

package/src/keyword/finally.md

@@ -1,6 +0,0 @@
----
-token: 'finally'
-reserved: true
----
-
-`finally` 是保留关键字。

package/src/keyword/fn.md

@@ -1,35 +0,0 @@
----
-token: 'fn'
----
-
-使用 `fn` 关键字定义一个函数或函数表达式。
-
----
-
-定义一个简单的函数：
-
-```mira
-fn add(a, b) {
-  return a + b;
-}
-```
-
----
-
-定义一个变量，并使用函数表达式初始化：
-
-```mira
-let multiply = fn (x, y) {
-  return x * y;
-};
-```
-
----
-
-当函数只有一个参数时，可以省略括号，并用 `it` 引用该参数。
-
-```mira
-fn square {
-  return it * it;
-}
-```

package/src/keyword/for.md

@@ -1,43 +0,0 @@
----
-token: 'for'
----
-
-`for` 用于遍历可迭代对象。
-
----
-
-遍历一个范围：
-
-```mira
-let mut sum = 0;
-for i in 1..3 { // 或者 1..<4
-  sum += i;
-}
-// sum == 6
-```
-
----
-
-遍历一个数组：
-
-```mira
-let arr = [10, 20, 30];
-let mut sum = 0;
-for value in arr {
-  sum += value;
-}
-// sum == 60
-```
-
----
-
-遍历一个记录：
-
-```mira
-let record = (a: 1, b: 2, c: 3);
-let mut sum = 0;
-for key in record {
-  sum += record[key];
-}
-// sum == 6
-```

package/src/keyword/global.md

@@ -1,29 +0,0 @@
----
-token: 'global'
----
-
-`global` 关键字用于读取全局变量或判断某个全局变量是否存在。
-
----
-
-当变量名与局部变量冲突时，可以使用 `global` 关键字来访问全局变量。
-
-```mira
-let some_name = 'shadow';
-some_name; // 访问局部变量 'some_name'
-global.some_name; // 访问全局变量 'some_name'
-```
-
----
-
-动态判断和访问全局变量：
-
-```mira
-fn get_global(name, fallback) {
-  if name in global {
-    global[name]
-  } else {
-    fallback
-  }
-}
-```

package/src/keyword/handle.md

@@ -1,6 +0,0 @@
----
-token: 'handle'
-reserved: true
----
-
-`handle` 是保留关键字。

package/src/keyword/if.md

@@ -1,40 +0,0 @@
----
-token: 'if'
----
-
-`if` 用于 `if` 表达式或 `match` 表达式的守卫条件。
-
----
-
-`if` 表达式根据条件选择分支。条件必须是 `boolean`。
-
-```mira
-let x = if 1 > 0 { "pos" } else { "neg" };
-```
-
----
-
-使用 `else if` 添加多个条件分支：
-
-```mira
-let x = if 1 > 2 {
-  "greater"
-} else if 1 == 2 {
-  "equal"
-} else {
-  "less"
-};
-```
-
----
-
-在 `match` 表达式中使用 `if` 作为守卫条件：
-
-```mira
-let num = 10;
-let result = match num {
-  case n if n % 2 == 0 { "even" }
-  case n { "odd" }
-};
-// result 的值是 "even"
-```

package/src/keyword/in.md

@@ -1,44 +0,0 @@
----
-token: 'in'
----
-
-`in` 用于“包含/存在”判断，以及 `for` 循环。
-
----
-
-对于 `array` 类型，`in` 用于判断某个元素是否在数组中存在：
-
-```mira
-fn is_spring(month) {
-  month in [3, 4, 5]
-}
-```
-
----
-
-对于 `record` / `module` / `extern` 类型，`in` 用于判断某个键是否在容器中存在：
-
-```mira
-let record = (a: 1, b: 2, c: 3);
-let a_exists = 'a' in record; // true
-```
-
----
-
-也可与 `global` 关键字结合使用，判断全局变量是否存在：
-
-```mira
-if 'my_global' in global {
-  my_global += 1;
-}
-```
-
----
-
-同时，`for` 循环也使用 `in`：
-
-```mira
-for i in 1..3 {
-  // i: 1, 2, 3
-}
-```

package/src/keyword/inf.md

@@ -1,10 +0,0 @@
----
-token: 'inf'
----
-
-`inf` 是正无穷大的 `number` 常量。
-
-```mira
-inf > 1e100; // true
--inf < 0;    // true
-```

package/src/keyword/is.md

@@ -1,11 +0,0 @@
----
-token: 'is'
----
-
-`is` 用于模式匹配：`value is pattern`，结果为 `boolean`。
-
-```mira
-1 is 1;        // true
-1 is > 0;      // true
-(a: 1) is (a: x); // true（并绑定 x）
-```

package/src/keyword/let.md

@@ -1,11 +0,0 @@
----
-token: 'let'
----
-
-`let` 用于声明局部变量。
-
-```mira
-let x = 1;
-let y = x + 2;
-let mut z = y * 3;
-```

package/src/keyword/loop.md

@@ -1,13 +0,0 @@
----
-token: 'loop'
----
-
-`loop` 创建一个无限循环，通常配合 `break` 退出。
-
-```mira
-let mut i = 0;
-loop {
-  i += 1;
-  if i >= 3 { break; }
-}
-```

package/src/keyword/match.md

@@ -1,18 +0,0 @@
----
-token: 'match'
----
-
-`match` 表达式对一个值进行分支匹配，由多个 `case` 组成。
-
-```mira
-fn classify {
-  match it {
-    case (0, 0) { "Origin" }
-    case (x, 0) if x > 0 { "Positive X-Axis (x=$x)" }
-    case (x, 0) if x < 0 { "Negative X-Axis (x=$x)" }
-    case (0, y) { "Y-Axis (y=$y)" }
-    case (x, y) { "Somewhere else (x=$x, y=$y)" }
-    case _ { "Not a point" }
-  }
-}
-```

package/src/keyword/mod.md

@@ -1,6 +0,0 @@
----
-token: 'mod'
-reserved: true
----
-
-`mod` 是保留关键字。

package/src/keyword/mut.md

@@ -1,25 +0,0 @@
----
-token: 'mut'
----
-
-`mut` 用于声明可变变量。
-
----
-
-使用 `let` 语句时声明一个可变变量：
-
-```mira
-let mut x = 1;
-x += 2;
-// x == 3
-```
-
----
-
-在模式匹配中声明一个可变绑定：
-
-```mira
-let (mut a, b) = (1, 2);
-a += 10;
-// b += 10; // 这行代码会报错，因为 b 是不可变的
-```

package/src/keyword/nan.md

@@ -1,10 +0,0 @@
----
-token: 'nan'
----
-
-`nan` 是一个特殊的 `number` 值（Not a Number）。它与任何值都不相等（包括它自己）。
-
-```mira
-nan == nan; // false
-nan =~ nan; // false
-```

package/src/keyword/nil.md

@@ -1,11 +0,0 @@
----
-token: 'nil'
----
-
-`nil` 表示“空值”。当访问不存在的字段、对 `nil` 进行空安全链式调用等场景时，结果也会是 `nil`。
-
-```mira
-let x = nil;
-let y = x ?? 0;     // 0
-let z = x.anything; // nil（空安全访问）
-```

package/src/keyword/not.md

@@ -1,26 +0,0 @@
----
-token: 'not'
----
-
-`not` 用于在模式匹配中取反一个模式，也可以作为 `!` 运算符的替代写法。
-
----
-
-逻辑非模式：
-
-```mira
-fn is_not_weekend(day) {
-  day is not 6 and not 7
-}
-```
-
----
-
-逻辑非运算符：
-
-```mira
-fn is_minor(age) {
-  // 等同于 !(age >= 18)
-  not (age >= 18)
-}
-```

package/src/keyword/op.md

@@ -1,6 +0,0 @@
----
-token: 'op'
-reserved: true
----
-
-`op` 是保留关键字。

package/src/keyword/or.md

@@ -1,26 +0,0 @@
----
-token: 'or'
----
-
-`or` 用于在模式匹配中组合多个模式，也可以作为 `||` 运算符的替代写法。
-
----
-
-逻辑或模式：
-
-```mira
-fn is_weekend(day) {
-  day is 6 or 7
-}
-```
-
----
-
-逻辑或运算符：
-
-```mira
-fn is_superuser(role) {
-  // 等同于 role == "admin" || role == "superuser"
-  role == "admin" or role == "superuser"
-}
-```

package/src/keyword/perform.md

@@ -1,6 +0,0 @@
----
-token: 'perform'
-reserved: true
----
-
-`perform` 是保留关键字。