typed_tuple_macros 0.1.0

Macro generation for the typed_tuple crate
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

extern crate proc_macro;

use proc_macro::TokenStream;
use quote::format_ident;
use syn::*;

mod typed_extract;
mod typed_index;
mod typed_split;

/// Implement `TypedIndex` on tuples of fields less than or equal to the given
/// integer literal.
///
/// # Example
/// `impl_typed_index!(12); // Implement on tuples of 1 to 12 fields.`
#[proc_macro]
pub fn impl_typed_index(item: TokenStream) -> TokenStream {
    match parse_int(item).map_err(|e| e.into_compile_error()) {
        Ok(n) => {
            let indices = indices(n);
            let generics = generics(n);

            (0..n + 1).fold(TokenStream::new(), |mut stream, i| {
                stream.extend(typed_index::impl_typed_index(i, &indices, &generics));
                stream
            })
        }
        Err(e) => e.into(),
    }
}

/// Implement `TypedSplit` on tuples of fields less than or equal to the given
/// integer literal.
///
/// # Example
/// `impl_typed_split!(12); // Implement on tuples of 1 to 12 fields.`
#[proc_macro]
pub fn impl_typed_split(item: TokenStream) -> TokenStream {
    match parse_int(item).map_err(|e| e.into_compile_error()) {
        Ok(n) => {
            let indices = indices(n);
            let generics = generics(n);

            (1..n + 1).fold(TokenStream::new(), |mut stream, i| {
                stream.extend(typed_split::impl_typed_split(i, &indices, &generics));
                stream
            })
        }
        Err(e) => e.into(),
    }
}

/// Implement `TypedExtract` on tuples of fields less than or equal to the given
/// integer literal.
///
/// # Example
/// `impl_typed_extract!(12); // Implement on tuples of 1 to 12 fields.`
#[proc_macro]
pub fn impl_typed_extract(item: TokenStream) -> TokenStream {
    match parse_int(item).map_err(|e| e.into_compile_error()) {
        Ok(n) => {
            let indices = indices(n);
            let generics = generics(n);

            (0..n + 1).fold(TokenStream::new(), |mut stream, i| {
                stream.extend(typed_extract::impl_typed_extract(i, &indices, &generics));
                stream
            })
        }
        Err(e) => e.into(),
    }
}

/// Parse an (unsigned) integer literal input.
fn parse_int(item: TokenStream) -> syn::Result<usize> {
    let lit = syn::parse::<ExprLit>(item)?;
    match lit.lit {
        Lit::Int(int) => int.base10_parse(),
        _ => Err(syn::Error::new_spanned(lit, "Expected integer literal")),
    }
}

fn indices(n: usize) -> Vec<Index> {
    (0..n + 1).map(|i| Index::from(i)).collect()
}

fn generics(n: usize) -> Vec<Ident> {
    (0..n + 1).map(|i| format_ident!("T{i}")).collect()
}