Fleet 语法参考手册
本文档提供了 Fleet 语言的完整语法参考，包括所有语言结构的详细说明和示例。
📋 目录
🔤 词法结构
标识符
// 标识符规则
identifier = letter (letter | digit | '_')*
letter = 'a'..'z' | 'A'..'Z'
digit = '0'..'9'
// 有效标识符示例
variable_name
camelCase
PascalCase
_private
value123
关键字
Fleet 语言的保留关键字：
// 控制流关键字
if else match loop break continue return
// 声明关键字
fn struct enum trait impl let var
// 类型关键字
int f64 str bool char
// 模式匹配关键字
Some None Ok Err
// 可见性关键字
pub mod use
// 异步关键字
async await
// 其他关键字
self Self true false
字面量
整数字面量
// 十进制
42
1_000_000
// 十六进制
0xFF
0x1A2B
// 八进制
0o755
// 二进制
0b1010_1111
// 类型后缀
42i32
100u64
浮点数字面量
// 基本浮点数
3.14
0.5
123.456
// 科学计数法
1e10
2.5e-3
1.23E+4
// 类型后缀
3.14f32
2.71828f64
字符串字面量
// 基本字符串
"Hello, World!"
"Fleet 语言"
// 转义序列
"Line 1\nLine 2"
"Tab\tSeparated"
"Quote: \"Hello\""
// 原始字符串
r"C:\Windows\System32"
r#"This contains "quotes""#
// 多行字符串
"""
This is a
multiline string
"""
字符字面量
// 基本字符
'a'
'1'
'中'
// 转义字符
'\n'
'\t'
'\''
'\\'
布尔字面量
true
false
注释
// 单行注释
/* 多行注释 */
/// 文档注释（用于函数、结构体等）
/// 这是一个示例函数
fn example() {}
/**
* 块状文档注释
* 支持多行
*/
struct Example {}
操作符
算术操作符
+ // 加法
- // 减法
* // 乘法
/ // 除法
% // 取模
** // 幂运算
比较操作符
== // 等于
!= // 不等于
< // 小于
<= // 小于等于
> // 大于
>= // 大于等于
逻辑操作符
&& // 逻辑与
|| // 逻辑或
! // 逻辑非
位操作符
& // 按位与
| // 按位或
^ // 按位异或
~ // 按位非
<< // 左移
>> // 右移
赋值操作符
= // 赋值
+= // 加法赋值
-= // 减法赋值
*= // 乘法赋值
/= // 除法赋值
%= // 取模赋值
其他操作符
. // 成员访问
:: // 路径分隔符
-> // 函数返回类型
=> // 匹配箭头
? // 错误传播
.. // 范围（不包含结束）
..= // 范围（包含结束）
🎯 表达式
字面量表达式
42 // 整数
3.14 // 浮点数
"hello" // 字符串
'a' // 字符
true // 布尔值
路径表达式
variable // 简单标识符
module::item // 模块路径
self // 当前实例
Self // 当前类型
二元表达式
a + b // 算术运算
x == y // 比较运算
p && q // 逻辑运算
n & m // 位运算
一元表达式
-x // 负号
!flag // 逻辑非
~bits // 按位非
函数调用表达式
function() // 无参数调用
function(arg1, arg2) // 有参数调用
object.method() // 方法调用
Type::associated_function() // 关联函数调用
索引表达式
array[index] // 数组索引
map<"key"> // 映射索引
matrix[row][col] // 多维索引
字段访问表达式
struct_instance.field // 字段访问
tuple.0 // 元组索引访问
范围表达式
1..10 // 1 到 9（不包含10）
1..=10 // 1 到 10（包含10）
..10 // 0 到 9
1.. // 1 到无穷
.. // 完整范围
数组表达式
[] // 空数组
[1, 2, 3] // 数组字面量
[0; 10] // 重复元素数组
[1, 2, ..rest] // 展开语法
元组表达式
() // 单元元组
(42,) // 单元素元组
(1, 2, 3) // 多元素元组
结构体表达式
Point { x: 10, y: 20 } // 结构体字面量
Point { x: 10, ..default } // 结构体更新语法
Point { x, y } // 字段简写
匹配表达式
match value {
pattern1 => expression1,
pattern2 if condition => expression2,
_ => default_expression,
}
条件表达式
if condition {
true_expression
} else {
false_expression
}
循环表达式
loop i in 0..10 {
// 循环体
}
loop {
// 无限循环
if condition { break; }
}
闭包表达式
|x| x + 1 // 简单闭包
|x, y| { x + y } // 多参数闭包
move |x| { captured + x } // 移动闭包
异步表达式
async { expression } // 异步块
await future_expression // 等待表达式
📝 语句
表达式语句
expression; // 表达式语句
function_call(); // 函数调用语句
赋值语句
variable = value; // 简单赋值
array[index] = value; // 索引赋值
struct.field = value; // 字段赋值
复合赋值语句
x += 5; // 等价于 x = x + 5
y *= 2; // 等价于 y = y * 2
z /= 3; // 等价于 z = z / 3
🏗️ 声明
变量声明
let identifier = expression; // 不可变变量
let identifier: type = expression; // 带类型注解
var identifier = expression; // 可变变量
var identifier: type = expression; // 可变变量带类型
函数声明
// 基本函数
fn function_name() {
// 函数体
}
// 带参数的函数
fn function_name(param1: type1, param2: type2) {
// 函数体
}
// 带返回类型的函数
fn function_name(param: type) -> return_type {
// 函数体
return expression;
}
// 泛型函数
fn function_name(param: T) -> T {
// 函数体
}
// 异步函数
async fn async_function() -> Future {
// 异步函数体
}
结构体声明
// 基本结构体
struct StructName {
field1: type1,
field2: type2,
}
// 元组结构体
struct TupleStruct(type1, type2);
// 单元结构体
struct UnitStruct;
// 泛型结构体
struct GenericStruct {
field: T,
}
枚举声明
// 基本枚举
enum EnumName {
Variant1,
Variant2,
}
// 带数据的枚举
enum EnumWithData {
Variant1(type1),
Variant2 { field: type2 },
Variant3(type3, type4),
}
// 泛型枚举
enum Option {
Some(T),
None,
}
Trait 声明
// 基本 trait
trait TraitName {
fn method_name(&self) -> return_type;
}
// 带默认实现的 trait
trait TraitWithDefault {
fn method_with_default(&self) -> return_type {
// 默认实现
}
fn abstract_method(&self) -> return_type;
}
// 泛型 trait
trait GenericTrait {
fn generic_method(&self, param: T) -> T;
}
Impl 块
// 为类型实现方法
impl TypeName {
fn method_name(&self) -> return_type {
// 方法实现
}
}
// 为类型实现 trait
impl TraitName for TypeName {
fn method_name(&self) -> return_type {
// trait 方法实现
}
}
// 泛型实现
impl TraitName for GenericType {
fn method_name(&self) -> return_type {
// 泛型实现
}
}
🎨 类型
基础类型
int // 有符号整数
i32 // 32位有符号整数
i64 // 64位有符号整数
u32 // 32位无符号整数
u64 // 64位无符号整数
f32 // 32位浮点数
f64 // 64位浮点数
bool // 布尔类型
char // 字符类型
str // 字符串类型
复合类型
[T] // 数组类型
[T; N] // 固定长度数组
(T1, T2, ...) // 元组类型
map // 映射类型
set // 集合类型
函数类型
fn() // 无参数无返回值函数
fn(T1, T2) -> R // 带参数和返回值的函数
fn(T) -> R where T: Trait // 带约束的函数类型
泛型类型
// 注意：Fleet 目前对泛型的支持有限
// 以下是当前支持的语法：
map // Map 类型使用方括号语法
Option // 简单枚举（暂不支持泛型参数）
Result // 简单枚举（暂不支持泛型参数）
// 未来计划支持的泛型语法：
// Option // 泛型枚举（计划中）
// Result // 双泛型枚举（计划中）
引用类型
&T // 不可变引用
&mut T // 可变引用
异步类型
Future // 异步 Future 类型
AsyncIterator // 异步迭代器类型
🎭 模式
字面量模式
match value {
42 => "forty-two",
true => "boolean true",
"hello" => "greeting",
'a' => "letter a",
}
标识符模式
match value {
x => x, // 绑定到变量 x
_ => "default", // 通配符模式
}
结构体模式
match point {
Point { x: 0, y: 0 } => "origin",
Point { x, y: 0 } => "on x-axis",
Point { x: 0, y } => "on y-axis",
Point { x, y } => "general point",
}
元组模式
match tuple {
(0, 0) => "origin",
(x, 0) => "on x-axis",
(0, y) => "on y-axis",
(x, y) => "general point",
}
枚举模式
match option {
Option::Some(value) => value,
Option::None => default_value,
}
match result {
Result::Ok(value) => value,
Result::Err(error) => handle_error(error),
}
范围模式
match number {
1..=10 => "small",
11..=100 => "medium",
101..=1000 => "large",
_ => "very large",
}
守卫模式
match value {
x if x > 0 => "positive",
x if x < 0 => "negative",
_ => "zero",
}
引用模式
match &value {
&Some(ref inner) => inner,
&None => &default,
}
🏷️ 属性
内置属性
#[derive(Debug, Clone, PartialEq)]
struct Example {
field: int,
}
#[inline]
fn fast_function() {
// 内联函数
}
#[test]
fn test_function() {
// 测试函数
}
#[cfg(debug)]
fn debug_only() {
// 仅在调试模式下编译
}
#[deprecated]
fn old_function() {
// 已弃用的函数
}
条件编译属性
#[cfg(target_os = "windows")]
fn windows_specific() {}
#[cfg(target_os = "linux")]
fn linux_specific() {}
#[cfg(feature = "advanced")]
fn advanced_feature() {}
文档属性
#[doc = "This is a documented function"]
fn documented_function() {}
/// 这是另一种文档注释方式
fn another_documented_function() {}
🔧 语法扩展
宏调用
println!("Hello, {}!", name);
vec![1, 2, 3, 4, 5];
format!("Value: {}", value);
宏定义
macro_rules! say_hello {
() => {
println!("Hello!");
};
($name:expr) => {
println!("Hello, {}!", $name);
};
}
📊 语法优先级
从高到低的操作符优先级：
- 字段访问、方法调用、索引：
.,[],() - 一元操作符：
!,-,~ - 乘法、除法、取模：
*,/,% - 加法、减法：
+,- - 位移：
<<,>> - 按位与：
& - 按位异或：
^ - 按位或：
| - 比较：
==,!=,<,<=,>,>= - 逻辑与：
&& - 逻辑或：
|| - 范围：
..,..= - 赋值：
=,+=,-=, 等 - 返回、跳出：
return,break