kozo提供了一些语法糖，以便更容易地使用Rust的结构体。
当前kozo提供以下2个proc宏

• define!
• retrieve!

define!

define! 宏可以以易于理解的方式定义嵌套结构体。

use kozo::define;

define!(struct NestedStruct {
    a: Vec<u8>,
    b: struct B {
        c: struct C {
            d: u8,
            e: u8,
        },
        f: enum F {
            X,
            Y,
            Other {
                name: String,
                id: usize
            },
        },
    },
});

fn main() {
    let sample = NestedStruct {
        a: vec![1, 1, 0, 1, 0, 1, 1],
        b: B {
            c: C {
                d: 0,
                e: 1,
            },
            f: F::X,
        },
    };

    println!("{}", sample.b.c.d);  // 0
}

( examples/define_sample.rs )

然后，define! 是定义每个命名的结构体分别的语法糖

struct DeepNestedStruct {
    a: Vec<u8>,
    b: B,
}
struct B {
    c: C,
    f: F,
}
struct C {
    d: u8,
    e: u8,
}
enum F {
    X,
    Y,
    Other {
        name: String,
        id: usize,
    },
}

所以请注意，在define!();中声明的所有结构体都在其作用域内可见。

retrieve!

retrieve! 允许从结构体简单地获取多个值

use kozo::{define, retrieve};

define!(struct Sample {
    a: u8,
    b: struct B {
        c: String,
        d: Vec<u8>,
    },
});

fn main() {
    let s = Sample {
        a: 0,
        b: B {
            c: "I have an apple?".into(),
            d: vec![1, 1, 0, 1, 0, 1, 1],
        },
    };
    retrieve!(a, b from s);

    println!("{a}");  // 0,
    println!("{}", b.c);
}

( examples/retrieve_sample.rs )

注意

在下一个版本（v0.2）中，

• define! 将能够接受 derive。

#[derive(Clone)]
define!(struct S {
    // ...
})

• retrieve! 将能够直接获取嵌套值，如下所示

let s = Sample {
    a: 0,
    b: B {
        c: "You have an apple!".into(),
        d: vec![1, 1, 0, 1, 0, 1, 1,],
    },
};
retrieve!(a, c(b), from s);

将来，retrieve! 将支持命名检索

let s = Sample {
    a: 0,
    b: B {
        c: "Is this an apple?".into(),
        d: vec![1, 1, 0, 1, 0, 1, 1,],
    },
};
retrieve!(var1 @ a, crazy_apple_man @ c(b), from s);

println!("{var1}");  // 0

对于日语使用者...
"kozo" 是 "小僧" 的发音，这个名字是结构体 "構造" 的命名，意味着提供有关结构体的微小且方便的功能的crate。