cached_field 1.0.2

Proc macro to cache associate function result on strut field. An analogy to python's @cached_property class decorator.
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

use proc_macro::TokenStream;
use syn::{
    parse::{ ParseStream, Parser}, parse_quote, punctuated::Punctuated, Error, FnArg, ReturnType, Token,
    Type, TypeReference,
};

pub fn split_comma<T>(args: TokenStream) -> Result<Punctuated<T, Token![,]>, Error>
where
    T: syn::parse::Parse,
{
    Punctuated::<T, Token![,]>::parse_terminated.parse(args)
}

pub fn split_comma_parse_stream<T>(args: ParseStream) -> Result<Punctuated<T, Token![,]>, Error>
where
    T: syn::parse::Parse,
{
    Punctuated::<T, Token![,]>::parse_terminated(args)
}

pub fn mut_receiver(
    mut inputs: Punctuated<FnArg, Token![,]>,
    check: bool,
) -> Punctuated<FnArg, Token![,]> {
    for input in inputs.iter_mut() {
        if let FnArg::Receiver(arg) = input {
            if check && arg.mutability.is_some() {
                panic!("compute function should take &self, not &mut self");
            }
            arg.mutability = parse_quote!(mut);
            if let Type::Reference(ty) = arg.ty.as_mut() {
                ty.mutability = parse_quote!(mut);
            }
        }
    }
    inputs
}

pub enum DuplAction {
    Throw,
    Prepend,
    Carry,
}

pub fn decor_output_amper(output: ReturnType, on_dupl: DuplAction) -> ReturnType {
    match &output {
        ReturnType::Type(tk, ty) => {
            if let Type::Reference(_) = **ty {
                match on_dupl {
                    DuplAction::Throw => panic!("function signature output already a reference!"),
                    DuplAction::Carry => return output,
                    _ => (),
                }
            }
            ReturnType::Type(
                *tk,
                Box::new(Type::Reference(TypeReference {
                    and_token: parse_quote!(&),
                    lifetime: None,
                    mutability: None,
                    elem: ty.clone(),
                })),
            )
        }

        _ => output,
    }
}

#[cfg(feature="throw")]
pub const DUPL_ACTION:DuplAction = DuplAction::Throw;
#[cfg(feature="prepend")]
pub const DUPL_ACTION:DuplAction = DuplAction::Prepend;
#[cfg(feature="carry")]
pub const DUPL_ACTION:DuplAction = DuplAction::Carry;