burbomath_macro 0.0.1

Macro crate for burbokop's rust math library
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

#![deny(warnings)]

use litrs::Literal;
use proc_macro::TokenStream;
use quote::quote;

fn validate_numeric_literal(
    input: TokenStream,
    predicate: fn(&Literal<String>) -> Result<(), TokenStream>,
) -> Result<(), TokenStream> {
    let input = input.into_iter().collect::<Vec<_>>();
    if input.len() != 1 {
        let msg = format!(
            "expected exactly one input token, but found {}",
            input.len()
        );
        return Err(quote! { compile_error!(#msg) }.into());
    }

    let lit = match Literal::try_from(&input[0]) {
        Ok(lit) => lit,
        Err(e) => return Err(e.to_compile_error()),
    };

    match lit {
        Literal::Integer(_) | Literal::Float(_) => predicate(&lit),
        _ => {
            let msg = format!("expected integer or float literal, but found {}", lit);
            Err(quote! { compile_error!(#msg) }.into())
        }
    }
}

fn must_be_positive(lit: &Literal<String>) -> Result<(), TokenStream> {
    match lit {
        Literal::Integer(lit) => {
            println!("int lit: {}", lit);
            if lit.value::<u128>().unwrap() == 0 {
                let msg = format!("expected positive number, but found {}", lit);
                return Err(quote! { compile_error!(#msg) }.into());
            }
        }
        Literal::Float(lit) => {
            println!("float lit: {}", lit);
            if lit.raw_input().parse::<f64>().unwrap() == 0. {
                let msg = format!("expected positive number, but found {}", lit);
                return Err(quote! { compile_error!(#msg) }.into());
            }
        }
        _ => unreachable!(),
    };
    Ok(())
}

#[proc_macro]
pub fn non_neg(input: TokenStream) -> TokenStream {
    let input2: proc_macro2::TokenStream = input.clone().into();

    if let Err(err) = validate_numeric_literal(input, |_| Ok(())) {
        return err;
    }

    quote! {
        unsafe { burbomath::NonNeg::new_const_unchecked(#input2) }
    }
    .into()
}

#[proc_macro]
pub fn positive(input: TokenStream) -> TokenStream {
    let input2: proc_macro2::TokenStream = input.clone().into();

    if let Err(err) = validate_numeric_literal(input, must_be_positive) {
        return err;
    }

    quote! {
        unsafe { burbomath::Positive::new_const_unchecked(#input2) }
    }
    .into()
}