Fleet 语法兼容性说明

本文档说明了 Fleet 语言当前实现的语法与文档中描述的语法之间的差异。

🚨 当前语法限制

1. 泛型支持有限

❌ 文档中的语法（尚未实现）：

Option
Result
Vec
fn generic_function(param: T) -> T

**✅ 当前实际语法**：
```fleet
Option          // 只支持具体类型，如 Some(int)
Result          // 只支持具体类型
map              // Map 类型使用尖括号语法

2. Option 和 Result 类型

当前 Option 实现： {{ ... }} enum Option { Some(int), // 只支持 int 类型 None }

fn divide(a: int, b: int) -> Option { if b == 0 { return Option::None; } else { return Option::Some(a / b); } }


**Result 类型状态**：
- 目前 Result 类型可能还未完全实现
- 文档中的示例主要是概念性的

### 3. Map 类型语法

**✅ 正确的 Map 语法**：
```fleet
// 类型声明
let scores = map{
    "Alice": 95,
    "Bob": 87
};

// 访问元素
let alice_score = scores["Alice"];

// 迭代（在某些示例中支持）
loop (key, value) in scores {
    print(key + ": " + value);
}

4. 方法调用限制

❌ 文档中提到但可能未实现的方法：

option.is_some()
option.unwrap()
option.unwrap_or(default)
map.get("key")
array.len()

✅ 当前可用的操作：

// 模式匹配（完全支持）
match option {
    Option::Some(value) => { /* 处理值 */ },
    Option::None => { /* 处理空值 */ }
}

// 基本数组/Map 操作
array[index]
map<"key">

📋 实际可用的语法特性

1. 基础类型

int, f64, str, bool, char  // ✅ 完全支持

2. 控制流

if condition { }           // ✅ 完全支持
loop i in 0..10 { }       // ✅ 完全支持（注意是 loop，不是 for）
match value { }           // ✅ 完全支持

3. 函数定义

fn function_name(param: type) -> return_type {
    // 函数体
}                         // ✅ 完全支持

4. 结构体

struct Point {
    x: int,
    y: int,
}

let p = Point { x: 10, y: 20 };  // ✅ 完全支持

5. 枚举

enum Color {
    Red,
    Green,
    Blue,
    RGB(int, int, int),
}                         // ✅ 完全支持

6. Trait 系统

trait Display {
    fn show(self) -> str;
}

impl Display for Point {
    fn show(self) -> str {
        return "Point";
    }
}                         // ✅ 完全支持

🔄 语法迁移指南

如果你在使用文档中的示例时遇到语法错误，请参考以下迁移指南：

Option 类型迁移

// ❌ 文档中的写法
fn find_user(id: int) -> Option { ... }

// ✅ 实际可用的写法
fn find_number(id: int) -> Option {
    if id > 0 {
        return Option::Some(id);
    } else {
        return Option::None;
    }
}

Map 操作迁移

// ❌ 文档中可能提到的写法
match map.get("key") {
    Option::Some(value) => { ... },
    Option::None => { ... }
}

// ✅ 实际可用的写法
let value = map<"key">;  // 直接访问

泛型函数迁移

// ❌ 文档中的写法
fn generic_function(param: T) -> T { ... }

// ✅ 实际可用的写法
fn int_function(param: int) -> int { ... }
fn str_function(param: str) -> str { ... }

🚀 未来计划

以下特性在未来版本中计划实现：

  1. 完整的泛型系统 - Option<T>, Result<T, E> 等
  2. 方法调用语法 - .len(), .get(), .unwrap() 等
  3. 更多集合类型 - Vec<T>, Set<T> 等
  4. 高级 trait 特性 - 关联类型、默认实现等

📞 报告语法问题

如果你发现文档中的语法与实际实现不符，请：

  1. 查看 examples/ 目录中的实际示例
  2. 参考本兼容性文档
  3. 在 GitHub Issues 中报告问题

🔗 相关资源