functor_derive_lib 0.4.3

The proc macro for a derive macro to derive a functor for a type.
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
112

use proc_macro2::{Ident, Span};
use proc_macro_error::{abort, abort_call_site};
use quote::format_ident;
use std::collections::HashSet;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::{parse, DeriveInput, GenericParam, Meta, Token};

pub fn parse_attribute(input: &DeriveInput) -> Attribute {
    functor_param_from_attrs(input).unwrap_or_else(|| functor_param_first(input))
}

fn functor_param_first(input: &DeriveInput) -> Attribute {
    input
        .generics
        .params
        .iter()
        .find_map(|param| {
            if let GenericParam::Type(typ) = param {
                Some(Attribute {
                    default: Some(typ.ident.clone()),
                    name_map: vec![],
                })
            } else {
                None
            }
        })
        .unwrap_or_else(|| abort_call_site!("Could not find a generic to map!"))
}

fn functor_param_from_attrs(input: &DeriveInput) -> Option<Attribute> {
    let mut functor_attribute = None::<(Attribute, Span)>;

    // Find upto one `functor` attribute.
    for attribute in &input.attrs {
        if let Meta::List(list) = &attribute.meta {
            // If there is more than one segment, it cannot be `functor`.
            if list.path.segments.len() > 1 {
                continue;
            }
            let Some(segment) = list.path.segments.first() else {
                continue;
            };
            if segment.ident != format_ident!("functor") {
                continue;
            }
            // We already found a `functor` attribute!
            if let Some((_, span)) = functor_attribute {
                abort!(span, "Found two functor attributes",)
            }
            let span = list.tokens.span();
            let param = parse(list.tokens.clone().into()).unwrap();
            functor_attribute = Some((param, span));
        }
    }

    functor_attribute.map(|(param, _)| param)
}

#[derive(Debug)]
pub struct Attribute {
    pub default: Option<Ident>,
    pub name_map: Vec<(Ident, Ident)>,
}

impl Parse for Attribute {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut default = None;
        let mut name_map = Vec::new();
        let mut seen_names = HashSet::new();

        for sub_attr in Punctuated::<SubAttribute, Token![,]>::parse_separated_nonempty(input)? {
            match sub_attr {
                SubAttribute::Default(param) => {
                    if default.replace(param).is_some() {
                        abort_call_site!("Two defaults were provided.")
                    }
                }
                SubAttribute::NameMap(param, name) => {
                    if !seen_names.insert(name.to_string()) {
                        abort_call_site!("Two identical fmap names were provided.")
                    }
                    name_map.push((param, name));
                }
            }
        }

        Ok(Attribute { default, name_map })
    }
}

enum SubAttribute {
    Default(Ident),
    NameMap(Ident, Ident),
}

impl Parse for SubAttribute {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let param = input.parse::<Ident>()?;

        let sub_attr = if input.peek(Token![as]) {
            input.parse::<Token![as]>()?;
            let name = input.parse::<Ident>()?;
            SubAttribute::NameMap(param, name)
        } else {
            SubAttribute::Default(param)
        };

        Ok(sub_attr)
    }
}