AbySS: 通过符号语法的高级脚本

AbySS (通过符号语法的高级脚本) 是一种旨在结合施法乐趣与高级脚本力量的编程语言。AbySS 旨在提供直观且符号丰富的语法，使开发者能够像施法一样与代码互动。无论您是编写简单的脚本还是构建复杂的系统，AbySS 都提供独特且沉浸式的体验。

主要特性

• 符号语法：AbySS 强调直观的符号语法，使代码易于阅读和编写，同时保持强大的功能。
• 受施法启发的编程：该语言的设计模仿了施法的体验，具有唤起魔法主题的保留关键字。
• 交互式施法：AbySS 通过解释器支持交互式脚本，允许实时执行和反馈。
• 结构化魔法：AbySS 鼓励结构化编程，结合了脚本的可塑性与结构代码的严谨性。
• VSCode 扩展：通过 AbySS Codex Familiar VSCode 扩展，提供语法高亮、代码补全和代码片段。

目录

• 安装
• 入门
• 语言语法
  • 基本语法
  • 类型
  • 类型转换
  • 变量声明
  • 条件语句
  • 循环
  • 函数
  • 输入/输出
• VSCode 扩展
• 路线图
• 许可证

安装

您可以使用 Cargo 从 crates.io 安装 AbySS。

cargo install abyss-lang

或者，您可以通过克隆仓库并在本地构建来安装 AbySS。支持 cargo-llvm-cov 用于测试覆盖率分析。

git clone https://github.com/your-repository/abyss.git
cd abyss
cargo install --path .

要使用 cargo-llvm-cov 进行测试覆盖率，按照以下步骤安装工具

rustup component add llvm-tools-preview
cargo install cargo-llvm-cov

入门

要开始使用 AbySS，您可以选择进入交互式解释器模式或运行 .aby 脚本文件。

运行解释器

您可以使用以下命令启动 AbySS 解释器

abyss cast

运行脚本

要运行 .aby 脚本文件，使用以下命令

abyss invoke <script.aby>

格式化代码

AbySS 提供了一个内置的代码格式化器，有助于在整个脚本中保持一致的代码风格。要格式化您的 .aby 脚本，使用以下命令

abyss align <script.aby>

此命令会自动根据语言的风格指南格式化您的代码。

语言语法

基本语法

AbySS使用受魔法主题启发的符号和直观的语法。以下是该语言的一些核心元素。

• 注释：AbySS中的注释用//标记单行注释，用/* */标记多行注释。

// This is a single-line comment
/*
  This is a multi-line comment
*/

类型

AbySS支持以下原始类型

• arcana：表示整数（例如，42，-3）。
• aether：表示浮点数（例如，3.14，-1.0）。
• rune：表示字符串（例如，"Hello, World"）。
• omen：表示布尔值，其中boon代表true，而hex代表false。
• abyss：表示void类型，表示没有值。

forge x: arcana = 10;
forge pi: aether = 3.14;
forge message: rune = "Hello, AbySS";
forge is_active: omen = boon;

• arcana：来源于拉丁语中“秘密”或“神秘”一词，同时也参考了塔罗牌的结构化编号，arcana表示整数值，象征着编程中计算的隐藏基础。
• aether：受古典元素以太的启发，以太被认为填满了地球球层以外的宇宙空间，aether表示浮点数，捕捉了流体、连续数量的概念。
• rune：借用了古代魔法中使用的书写系统，rune表示字符串，暗示着在编程中，如同在神秘的铭文一样，词语和符号具有力量。
• omen：从预言的符号这一概念中汲取灵感，omen表示布尔值。关键字boon和hex分别用于true和false，其中boon源自古英语，意为祝福或利益，而hex来自日耳曼民间传说，表示诅咒或咒语，强化了该语言的神秘主题。
• abyss：象征着无限的虚无，abyss表示void类型，表示没有返回值，也是该语言的名字，反映了其探索符号脚本深度的哲学。

类型转换

在AbySS中，使用trans关键字来实现类型转换。这允许将值从一个类型转换为另一个类型。

trans：简称为“transformation”，trans允许将一种类型转换为另一种类型，反映了编程中的魔法转换概念。

forge x: arcana = trans(3.14 as arcana);

变量声明

使用forge关键字声明变量。您必须明确指定变量类型。

forge x: arcana = 42;
forge greeting: rune = "Welcome to AbySS!";

要声明可变变量，使用morph关键字与forge一起。

forge morph counter: arcana = 10;
counter += 5;

• forge：来源于铁匠锻造物品的概念，该关键字表示创建和声明新变量，象征着创造新事物的行为。
• morph：受变换的启发，morph用于表示可变变量，其形式或值可以随时间改变。

条件语句

在AbySS中，您可以使用oracle构造来处理条件。一种方法是在每个模式中直接定义条件，允许灵活且可读的分支逻辑。这种方法允许您跳过单独的条件语句，并在分支自身内编写所有条件。

• oracle：反映古代神话中占卜者的角色，此关键字用于条件语句，决策和预测基于输入进行。

基于模式的占卜

forge x: arcana = -5;
oracle {
    (x > 0) => unveil("x is positive");
    (x < 0) => unveil("x is negative");
    _ => unveil("x is zero");
};

在这个例子中，条件直接写在了模式中。占卜者按顺序评估每个条件并执行匹配的分支。如果没有满足特定条件，将执行默认模式 _。

基于布尔值的占卜

使用 oracle 的另一种方法是明确地将条件作为 oracle 表达式的一部分编写，这可以评估为 omen（布尔）值。

oracle (x > 0) {
    (boon) => unveil("x is positive");
    (hex) => unveil("x is non-positive");
};

这里，条件 x > 0 被评估为 boon（true）或 hex（false），并根据此结果执行适当的分支。

基于值的占卜

您还可以在 oracle 中使用表达式或赋值来进行更复杂的评估。

forge y: arcana = 42;
oracle (z = y * 2) {
    (z > 50) => unveil("z is greater than 50");
    (z == 50) => unveil("z equals 50");
    _ => unveil("z is less than 50");
};

在这种情况下，z 被分配了 y * 2 的结果，并根据 z 的计算值选择适当的分支。

基于多个条件的占卜

您还可以在单个占卜结构中处理多个条件，从而允许根据多个变量进行复杂的分支。

forge a: arcana = 3;
forge b: arcana = 2;

oracle (a, b) {
    (1, 2) => unveil("a is 1 and b is 2");
    (3, 2) => unveil("a is 3 and b is 2");
    _ => unveil("Other combination");
};

在这个例子中，占卜者评估多个条件（a 和 b）并一起执行相应的分支，根据它们的值。如果没有满足特定条件，则使用默认模式 _。

这种灵活性使 oracle 成为在 AbySS 中创建可读和直观的分支逻辑的有力工具。

循环

AbySS 中使用 orbit 关键字来管理循环。此结构允许简单的循环结构，以及通过 resume 和 eject 关键字提供的额外控制。以下我们将探讨 AbySS 中循环的多种用例，从基本到高级场景。

• orbit：受到行星天体运动灵感的启发，轨道表示循环，代码围绕中心任务重复执行，直到条件发生变化。
• resume：反映中断任务的继续，允许循环跳过当前迭代并继续到下一个。
• eject：类似于紧急出口或逃生机制，eject 在条件满足时跳出循环，提前终止迭代。

简单循环

AbySS 中循环的最基本形式是遍历值范围。在这个例子中，循环从 0 迭代到 5（不包括 5）。

orbit (i = 0..5) {
    unveil(i);
}

这个循环使用 unveil 函数打印从 0 到 4 的数字。运算符 .. 定义了一个半开区间，不包括上限。

闭区间循环

您可以使用运算符 ..= 创建闭区间循环，该运算符将上限包含在迭代中。

orbit (i = 0..=10) {
    unveil(i);
}

在这个循环中，打印从 0 到 10（包括）的数字。

无限循环

通过省略循环参数，您可以创建一个无限循环，直到满足某个条件为止。当条件满足时，可以使用 eject 关键字终止循环，该关键字在条件满足时跳出循环。

forge morph i: arcana = 0;
orbit {
    oracle (i == 100) {
        (boon) => eject; // Break the loop when i equals 100
    };
    i += 1;
};
unveil(i); // Prints 100 after loop termination

这个例子在每次迭代中将 i 增加，直到它达到 100，此时循环退出。

具有多个参数的循环

AbySS 允许您定义包含多个参数的循环，这使得同时迭代多个范围变得更容易。以下是一个示例，其中定义了两个循环变量 i 和 j。

orbit (i = 0..3, j = 0..3) {
    unveil(i, " ", j);
}

在这个循环中，i 和 j 都迭代从 0 到 2 的范围，并打印每一对值。这种模式在需要同时执行依赖于两个或多个变化值的操作时很有用。

恢复关键字

resume 关键字允许您跳过循环的当前迭代并继续到下一次迭代。这可以用来控制嵌套循环的流程。

orbit (i = 0..3) {
    orbit (j = 0..3) {
        oracle (i == j) {
            (boon) => resume j; // Skip the iteration when i equals j
        };
        unveil(i, " ", j);
    }
}

在这个例子中，当 i 等于 j 时，内层循环会跳过迭代。

退出关键字

eject 关键字完全中断循环。在嵌套循环中，您可以通过传递循环变量作为参数来指定要中断哪个循环。

orbit (i = 0..3) {
    orbit (j = 0..3) {
        unveil(i, " ", j);
        oracle (i == 2) {
            (boon) => eject i; // Break the outer loop when i equals 2
        };
    }
}

在这里，当 i 等于 2 时，外层循环完全中断，从而终止了内层和外层循环。

这些示例说明了 AbySS 中 orbit 构造的灵活性，它允许使用易于阅读的语法实现复杂的循环模式。使用 resume 和 eject 关键字来控制流程，进一步增强了该语言在处理循环时的表达能力。

函数

在 AbySS 中，使用 engrave 关键字定义函数。函数允许您封装可重用代码块并返回值。您可以在脚本中定义带有参数的函数，指定返回类型，并调用这些函数。

• engrave：象征着刻画魔法圆圈的行为，engrave 用于函数定义，代表将可重用咒语精细地刻入代码的过程。

函数定义

使用 engrave 关键字定义函数，后跟函数名、参数、可选返回类型，以及用 { 和 } 包围的函数体。

engrave add(a: arcana, b: arcana) -> arcana {
    reveal a + b;
};

在这个例子中，add 函数接受两个参数 a 和 b，其类型为 arcana（整数），并返回它们的和，也是一个 arcana。

函数调用

您可以通过使用函数名后跟括号来调用函数，并传递与函数参数匹配的参数。

forge result: arcana = add(3, 5);
unveil(result); // Outputs: 8

这个例子使用参数 3 和 5 调用 add 函数，将结果存储在 result 变量中，并使用 unveil 打印它。

嵌套函数调用

AbySS 允许您在函数调用中调用函数，这使得可以将复杂操作分解为更简单的组件。

engrave add_three_numbers(x: arcana, y: arcana, z: arcana) -> arcana {
    reveal add(add(x, y), z);
};

forge result: arcana = add_three_numbers(1, 2, 3);
unveil(result); // Outputs: 6

在这个例子中，add_three_numbers 函数两次调用 add 函数来求和三个数字。

返回值

AbySS 中的函数使用 reveal 关键字返回值。如果函数没有明确返回值，它隐式返回 abyss。

engrave greet() -> rune {
    reveal "Hello, AbySS!";
};

unveil(greet()); // Outputs: Hello, AbySS!

这个函数 greet 返回一个 rune（字符串），并使用 unveil 打印它。

递归函数

AbySS 支持递归函数调用，允许函数调用自身。

engrave factorial(n: arcana) -> arcana {
    oracle (n <= 1) {
        (boon) => reveal 1;
    };
    reveal n * factorial(n - 1);
};

forge result: arcana = factorial(5);
unveil(result); // Outputs: 120

这个递归函数计算一个数的阶乘。

输入/输出

对于输出，AbySS 使用 unveil 函数将值打印到控制台。您可以通过逗号分隔传递多个变量或表达式作为参数。这允许您在输出中连接不同的元素。

• unveil：因其揭示隐藏事物的隐喻意义而选择，unveil用于输出操作，使程序内部状态对用户可见。

unveil("Hello, AbySS");
unveil("x + 42 = ", x + 42);

在上面的示例中，第二个unveil语句在同一行上打印了字符串"x + 42 = "和表达式x + 42的结果。

对于输入，AbySS提供了summon函数在脚本执行期间读取用户输入。该summon函数接受提示消息和预期类型作为参数。

• summon：表示从用户那里召唤某物的行为，summon用于标准输入操作。您可以指定提示和期望的输入类型（例如，arcana，aether，rune）。

forge name: rune = summon("Input your name: ", rune);
forge age: arcana = summon("Input your age: ", arcana);
unveil("Hello, ", name, "! You are ", age, " years old.");

在这个示例中，用户被提示输入他们的姓名和年龄。然后，输入存储在name和age变量中，并且都使用unveil打印。

VSCode 扩展

AbySS Codex Familiar VSCode扩展提供了对AbySS开发的额外支持，包括

• 关键字、类型、常量和运算符的语法高亮。
• 常见结构（如forge、unveil和oracle）的代码片段。
• 关键AbySS结构的自动完成。

要安装扩展，请在Visual Studio Code扩展市场中搜索"AbySS Codex Familiar"，或从GitHub存储库下载。

路线图

• 集合类型：实现集合类型，如列表和字典，用于处理多个值（进行中）。
• 结构实现：启用自定义数据结构的定义和使用（待定）。
• 泛型引入：引入泛型，以使函数和数据结构可以更灵活和可重用地使用不同类型（待定）。
• 模块系统：引入从其他文件导入函数和变量的能力（待定）。
• 错误处理：实现健壮的错误处理（待定）。
• 文件I/O：引入输入功能和处理文件（待定）。
• 标准库：开发一个包含常见函数和工具的标准库（待定）。
• 解释器增强：通过更好的实时反馈、调试功能和性能优化改进交互式解释器（待定）。

许可证

AbySS是开源软件，根据MIT许可证授权。有关详细信息，请参阅LICENSE文件。