当前 atruct 提供以下与匿名结构相关的 3 个宏

• atruct!
• #[返回]
• #[withReturn]

atruct!

受 structx（现在不可用）的启发，atruct! 宏允许使用匿名结构体的变量，如下所示：

use atruct::atruct;

fn main() {
    let anonymous = atruct!(
        // Type annotaion is needed for each non-literal value.
        // There are 2 options to annotate type:

        string1 @ String: String::from("string1"),  // @ pattern and
        string2(String): String::from("string2"),  // () pattern.
        // Their behaviors are completely the same. Use any one you like!

        box_option_vec @ Box<Option<Vec<u8>>>: Box::new(Some(Vec::new())),
        vec(Vec<u8>): vec![0, 1, 0, 1, 1],

        nest: {
            a: "you can define nested struct without prepare lots of named structs",
            b: 100usize,  // literals don't need type annotation
        },
    );

    println!("{}", anonymous.string1);  // string1
    println!("{}", anonymous.string2);  // string2
    println!("{:?}", anonymous.box_option_vec);  // Some([])
    println!("{:?}", anonymous.vec);  // [0, 1, 0, 1, 1]
    println!("{}", anonymous.nest.a)  // you can define nested struct without prepare lots of named structs
}

( examples/struct_of_various_values.rs )

• atruct! 支持 嵌套结构。

• 当 atruct 版本为 v0.1 时，仅支持字面量作为值，但自 v0.2 版本起，您可以使用（可能）任何类型的值！

#[Return]

通常，我们从函数中返回多个值。在这种情况下，Rust 仅支持 元组 作为捆绑返回值的唯一方式。但有时这有点烦人：当我们想给每个字段自由命名时，不是 0，1，2，...

#[Return] 属性允许这种命名。您可以编写如下函数：

use atruct::Return;

fn main() {
    let abc = get_abc();
    println!("{}", abc.a);  // 24
    println!("{}", abc.b);  // you can use any value in a field
    println!("{:?}", abc.c);  // [-1, 0, 0, -1, 1, 0, 1, -1]
}

#[Return(a: u8, b: String, c: Vec<isize>)]  // not supporting nest
fn get_abc() {
    Return {
        a: 24,
        b: "you can use any value in a field".into(),
        c: vec![-1,0,0,-1,1,0,1,-1],
    }
}

( examples/return_struct.rs )

• #[Return] 不支持嵌套结构。因此，返回值就像是一个可以为其字段命名任何名称的 元组。
• #[Return] 自动生成一个名为“FunctionName”的 struct（例如，如果函数是 get_abc，例如，GetAbc），但同时也定义了一个同义词类型 Return。因此，您 不需要 记忆生成的 struct 的名称。

#[withReturn]

实际上，由于技术原因，#[Return] 本身并不在 impl 块中可用。#[withReturn] 允许这样做：

use atruct::withReturn;

fn main() {
    let abc = T::get_abc();
    println!("abc: {{a: {}, b: {}, c: {:?}}}", abc.a, abc.b, abc.c);
    // abc: {a: 0, b: I am b, c: [1, 0, -1, 0]}
}

struct T;
#[withReturn]
impl T {
    #[Return(a: u8, b: String, c: Vec<isize>)]
    fn get_abc() {
        Return {
            a: 0,
            b: "I am b".into(),
            c: vec![1, 0, -1, 0],
        }
    }
}

( examples/return_in_impl_block.rs )

• 如您所见，您无需使用use atruct::Return来在impl块中写入#[Return]。
• 当前的#[withReturn]生成结构与正常的#[Return]完全相同，这意味着使用#[Return]的所有函数都必须有唯一的名字（这个问题将在几天内解决）。