atruct 0.3.2

macros for anonymous structs in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use proc_macro2::{Ident, Span, Punct};
use syn::{
    punctuated::Punctuated,
    token::{Comma, Colon, Brace, At, Paren, Bang, Sub},
    parse::{Parse, ParseStream},
    braced, Expr, Type, parenthesized, Error
};


pub struct Atruct {
    fields: Punctuated<Field, Comma>,
}
#[derive(Clone)]
pub struct Field {
    pub name:            Ident,
    pub type_annotation: Option<TypeAnnotation>,
    _colon:              Colon,
    pub content:         FieldContent,
}
#[derive(Clone)]
pub enum TypeAnnotation {
    AtAnnotation {
        _at:           At,
        type_of_value: Type,
    },
    ParenAnnotation {
        _paren:        Paren,
        type_of_valle: Type,
    },
}
#[derive(Clone)]
pub enum FieldContent {
    Value {
        prefix: Option<Prefix>,
        expr:   Expr,
    },
    Nest {
        _brace: Brace,
        fields: Punctuated<Field, Comma>,
    },
}
#[derive(Clone)]
pub enum Prefix {
    Bang,
    Minus,
}


impl Atruct {
    pub fn into_fields(self) -> Punctuated<Field, Comma> {
        self.fields
    }
} impl Parse for Atruct {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(Atruct {
            fields: input.parse_terminated(Field::parse)?
        })
    }
} impl Parse for Field {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(Field {
            name: input.parse().expect("expected identifier / not supporting block value like `field: {let v = Vec::new(); v}`"),
            type_annotation:
                if input.peek(At)
                || input.peek(Paren) {
                    Some(input.parse()?)
                } else {None},
            _colon:  input.parse()?,
            content: input.parse()?,
        })
    }
} impl Parse for TypeAnnotation {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        if input.peek(At) {
            Ok(Self::AtAnnotation {
                _at:           input.parse()?,
                type_of_value: input.parse()?,
            })
        } else if input.peek(Paren) {
            let type_buf;
            Ok(Self::ParenAnnotation {
                _paren:        parenthesized!(type_buf in input),
                type_of_valle: type_buf.parse()?,
            })
        } else {
            Err(Error::new(Span::call_site(), "unexpected type annotation"))
        }
    }
} impl Parse for FieldContent {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let fields_buf;
        if input.peek(Brace) {
            Ok(Self::Nest {
                _brace: braced!(fields_buf in input),
                fields: fields_buf.parse_terminated(Field::parse)?,
            })
        } else {
            Ok(Self::Value {
                prefix:
                    if input.peek(Bang) {
                        input.parse::<Punct>().unwrap();
                        Some(Prefix::Bang)
                    } else if input.peek(Sub) {
                        input.parse::<Punct>().unwrap();
                        Some(Prefix::Minus)
                    } else {None},
                expr: input.parse()?
            })
        }
    }
}