语法定义如下

ByteVector = "#u8(" Byte* ')'
Byte       = <any exact integer between 0 and 255>

解析器定义如下

use kamo::parser::{code, prelude::*, Input, ParseError, ParseResult, Span};

fn main() {
    assert_eq!(
        parse_bytevec(Input::new("#u8(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)")),
        Ok((
            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
            Input::new("")
        ))
    );
}

fn parse_bytevec(input: Input<'_>) -> ParseResult<'_, Vec<u8>> {
    context_as(
        delimited(
            pair(tag("#u8("), ascii::whitespace0),
            list0(parse_bytevec_value, ascii::whitespace1),
            context_as(
                preceded(ascii::whitespace0, char(')')),
                code::ERR_CUSTOM + 2,
                "expecting a closing parenthesis: )",
            ),
        ),
        code::ERR_CUSTOM + 1,
        "expecting a byte vector: #u8(<byte>*)",
    )(input)
}

fn parse_bytevec_value(input: Input<'_>) -> ParseResult<'_, u8> {
    let result = preceded(
        ascii::whitespace0,
        any((
            parse_binary_natural,
            parse_octal_natural,
            parse_decimal_natural,
            parse_hexadecimal_natural,
            parse_natural,
        )),
    )(input);

    match result {
        Ok((value, cursor)) => {
            if value > u8::MAX as u64 {
                Err(ParseError::new(
                    Span::new(input.position(), cursor.position()),
                    code::ERR_CUSTOM + 3,
                    "expecting a byte value: 0..255",
                ))
            } else {
                Ok((value as u8, cursor))
            }
        }
        Err(err) => Err(err),
    }
}

#[inline]
fn parse_binary_natural(input: Input<'_>) -> ParseResult<u64> {
    preceded(tag("#b"), literal::natural(literal::Radix::Binary))(input)
}

#[inline]
fn parse_octal_natural(input: Input<'_>) -> ParseResult<u64> {
    preceded(tag("#o"), literal::natural(literal::Radix::Octal))(input)
}

#[inline]
fn parse_decimal_natural(input: Input<'_>) -> ParseResult<u64> {
    preceded(tag("#d"), parse_natural)(input)
}

#[inline]
fn parse_hexadecimal_natural(input: Input<'_>) -> ParseResult<u64> {
    preceded(tag("#x"), literal::natural(literal::Radix::Hexadecimal))(input)
}

#[inline]
fn parse_natural(input: Input<'_>) -> ParseResult<u64> {
    literal::natural(literal::Radix::Decimal)(input)
}

类型系统

当启用《types》功能时，类型系统可用。默认情况下没有启用。当启用类型系统时，《env》模块也可用。它被《TypeChecker》使用。

类型通过类型代码定义，类型代码是一个字节数组。类型代码用于表示值的类型。这允许以简单有效的方式表示类型。类型代码的语法简单易懂，易于解析。类型代码允许通过组合更简单的类型构建具有多级嵌套的复杂类型。

支持的基本类型如下

• 布尔型：布尔值。
• 字符：Unicode字符。
• 整数：有符号整数值。
• 浮点型：浮点值。
• 符号：内部字符串值。
• 类型：类型值。
• 二进制：字节数组值。

除了基本类型外，类型系统还支持以下复合类型

• 数组：同构元素集合。
• 对：两个值的对，也称为cons单元。
• Lambda：函数类型。
• Option：可以是《None》或《Some(T)》的类型。
• Union：可以是给定类型之一的数据类型。联合中必须至少有两个类型。

还支持特殊类型

• Any：可以是任何值的类型。
• Void：不能是任何类型或值的类型。它用于表示类型的缺失。它用于表示不返回值或不需要任何参数的函数的上下文中。
• Nil：表示值缺失的类型。它在可选类型上下文中使用。

类型被分组到不同的类别中

• 特定类型：代表特定值并且可以是联合类型成员的类型。以下是一些特定类型：布尔型、字符型、整型、浮点型、符号型、类型型、二进制型、数组型、对型和lambda。
• 填充类型：代表更通用的特定值。这些类型可以用在选项类型中。以下是一些填充类型：Any、Union和特定类型。

解析器

类型系统包括两个解析器：类型代码解析器和类型文本表示解析器。类型代码解析器用于解析类型代码并将它们转换为类型。类型文本表示解析器用于解析字符串并将它们转换为类型。类型的文本表示是一种人类可读格式，可以用来以比类型代码更可读的方式表示类型。

类型检查器

TypeChecker特质用于实现解释器或编译器的类型检查。类型检查器用于检查一个值是否具有特定的类型或者一个类型是否是另一个类型的子类型。类型检查器还可以用于推断表达式或值的类型。类型检查器用于实现编程语言中的类型推断和类型检查。

宏

宏用于将字符串字面量解析为单个或多个kamo::value::Value值。宏定义如下

• sexpr!(<mutator>, <expression>) - 用于从字符串解析单个s-expressions的宏。它返回一个kamo::value::Value。

• sexpr_file!(<mutator>, <filename>) - 用于从文件解析多个s-expressions的宏。它返回一个kamo::value::Value值的数组。该数组可能为空。

• sexpr_script!(<mutator>, <expressions>) - 用于从字符串解析多个s-expressions的宏。它返回一个kamo::value::Value值的数组。该数组可能为空。

所有宏都接受一个可选的MutatorRef标识符。这用于在堆上分配值。如果表达式不包含需要在堆上分配的任何值，则可以省略Mutator标识符。

宏的语法由Scheme标准R7RS中的read过程定义。语法定义在标准的第"7.1.2 外部表示法"部分中。

与标准的语法偏差如下

• 不支持数字的精确度（#e 和 #i）。浮点数总是不精确的，整数总是精确的。

• 数字只能是带有符号的64位整数或IEEE 754双精度浮点数。标准允许任意精度的整数、有理数和复数。

• 不支持标签。

• #; 注释语法仅在解析多个s-expressions的宏中受支持。#; 注释语法不能嵌套。

• 由十六进制转义序列定义的字符字面量可以有1到6位数字。标准期望至少有1位数字。代码必须是有效的Unicode码点。

解析器使用 pest crate 实现。语法定义在 src/sexpr/sexpr.pest。这是必要的，因为在此处无法使用在 kamo::parser 中定义的解析器库。这会导致循环依赖。将来将在 kamo::form 模块中实现s-expressions解析器的实现。它将基于 kamo::parser crate，并将被scheme解释器使用。

示例

use kamo::{mem::Mutator, sexpr, value::{print, Value}};
 
let m = Mutator::new_ref();
let value = sexpr!(m, "(1 2 3)");
 
assert_eq!(print(value).to_string(), "(1 2 3)");

use kamo::{sexpr_file, value::{print, Value}};
 
let m = Mutator::new_ref();
let values = sexpr_file!("tests/sexpr/values.scm");
 
assert_eq!(values.len(), 3);
assert_eq!(print(values[0].clone()).to_string(), "()");
assert_eq!(print(values[1].clone()).to_string(), "100");
assert_eq!(print(values[2].clone()).to_string(), "#t");

let values: &[Value] = &sexpr_file!("tests/sexpr/empty.scm");
assert_eq!(values.len(), 0);

use kamo::{mem::Mutator, sexpr_script, value::{print, Value}};
 
let m = Mutator::new_ref();
let values = sexpr_script!(m, "(define a 1)\n(define b 2)\n(+ a b)");
 
assert_eq!(values.len(), 3);
assert_eq!(print(values[0].clone()).to_string(), "(define a 1)");
assert_eq!(print(values[1].clone()).to_string(), "(define b 2)");
assert_eq!(print(values[2].clone()).to_string(), "(+ a b)");

let values: &[Value] = &sexpr_script!("");
 
assert_eq!(values.len(), 0);

特性列表

• 模块 kamo::parser 用于解析UTF-8文本。一个用于安全且零拷贝方式解析UTF-8文本的解析器组合库。
• 模块 kamo::mem 用于自动内存管理。值在持有每个类型的竞技场的分配器的mutator中分配。内存收集由标记和清除垃圾回收器完成。
• 模块 kamo::value 用于值。值可以持有立即值或指向在mutator中分配的值的指针。
• 模块 kamo::types 用于类型。类型系统用于推断中间表示和AST的类型。
• 模块 kamo::eval 用于评估。评估器处理AST（符号表达式树），并将其评估为中间表示。中间表示可以随后被解释或编译为目标表示。解释器是通用的，可以用于解释任何中间表示。
• 模块 kamo::repl 用于读取-评估-打印循环。REPL用于交互式评估表达式，是通用的，可以用于评估任何中间表示。
• 模块 kamo::lang::scheme 用于Scheme语言。Scheme语言作为库在 kamo 模块之上实现。它实现了R7RS标准的子集。