类型声明

类型别名

使用 type NewType = ExistingType 创建类型别名，这是联合类型的特例。

枚举(Enums)

枚举是一组命名整型常量，默认从0开始递增：

enum Color as u8 {
    red   // 0
    green // 1
    blue  // 2
}

特性：

• 支持显式赋值：enum Grocery { apple; orange=5; pear }
• 可定义方法：

fn (c Cycle) next() Cycle {
    match c { ... }
}

• 支持字符串/整型转换：

println(Cycle.from('two')!) // "two"
println(Cycle.one.str())    // "one"

函数类型

使用类型别名定义函数签名：

type Filter = fn (string) string

fn filter(s string, f Filter) string {
    return f(s)
}

兼容函数自动匹配：

// 函数签名兼容即可使用
println(filter('hello', uppercase))

接口(Interfaces)

定义包含字段和方法的契约：

interface Speaker {
    breed string
    speak() string
}

实现规则：

1. 需实现接口所有方法和字段
2. mut: 部分需可变接收者：

interface Bar {
mut:
    write(string) string
}
// 需实现为：fn (mut s Type) write(a string) string

类型检查

if s is Dog { // 自动转换为具体类型
    println(s.breed) 
}

嵌入式接口

组合多个接口：

interface ReaderWriter {
    Reader
    Writer
}

联合类型(Sum types)

可容纳多种类型的值：

type World = Mars | Moon | Venus
world := World(Moon{})
println(world.type_name()) // "Moon"

递归结构示例（二叉树）：

type Tree = Empty | Node
fn sum(tree Tree) f64 {
    match tree {
        Empty { 0 }
        Node { tree.value + sum(tree.left) + sum(tree.right) }
    }
}

动态转换

安全转换需结合智能转换：

if mut w is Mars { // 可变变量需mut
    w.dust_storm() // 自动识别为Mars类型
}

选项/结果类型

错误处理核心机制：

// 结果类型（!）
fn find_user(id int) !User { 
    return error('Not found') 
}

// 选项类型（?）
fn find_user(id int) ?User {
    return none
}

处理方式：

1. 错误传播：resp := http.get(url)!
2. 中断执行：user := repo.find_user(7) or { return }
3. 默认值：b := do_something('bar') or { 'default' }
4. if解包：

if resp := http.get(url) {
    // 成功分支
} else {
    println(err)
}

自定义错误类型

实现 IError 接口：

struct PathError {
    Error // 嵌入默认实现
    path string
}

fn (err PathError) msg() string {
    return '路径错误: ${err.path}'
}

泛型(Generics)

类型参数化：

struct Repo[T] { db DB }

fn (r Repo[T]) find_by_id(id int) ?T {
    table_name := T.name // 获取类型名
    return r.db.query_one[T]('...', id)
}

// 使用
users_repo := new_repo[User](db)
user := users_repo.find_by_id(1)?

函数泛型：

fn compare[T](a T, b T) int {
    if a < b { return -1 }
    ...
}
println(compare(1.1, 1.2)) // -1