atruct!

inspired by structx (that doesn't work now), atruct! macro enables to use variables of anonymous structs like

```rs 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/structofvarious_values.rs )

atruct! supports nested structs.
When atruct was v0.1 only literals are supported as values, BUT in v0.2 you can use (maybe) any type of values!

#[Return]

We usually return more than 1 values from a function. In such situations, Rust supports only tupple as a way to bundle returned values. But it's sometimes a bit anoying: when we'd like to name freely to each field, not 0, 1, 2, ...

#[Return] attribute enables such naming. You can write functions like

```rs 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)] // not supporting nest

fn getabc() { Return { a: 24, b: "you can use any value in a field".into(), c: vec![-1,0,0,-1,1,0,1,-1], } } ``` ( examples/returnstruct.rs )

Unlike atruct!, #[Return] doesn't support nested structs. So returned value is just like a tupple you can give any names to its fields.
#[Return] automatically generates a struct named as "FunctionName" ( e.g. if function is get_abc, for example, GetAbc ), but at the same time defines a type synonym Return. So you DON't need to memorize the generated struct's name.

NOTICE: I'm plannig to implement #[Atruct] attribute in next version (v0.3). This will enable to define nested struct easily like

```rs

[Atruct]

struct DeepNestedStruct { a: Vec, b: struct B: { c: String, d: struct D { e: u8, f: u8, }, }, b2: B, e: struct E { f: &'static str, g: enum G { X, Y, Other { name: String, id: usize }, }, }, } ```