tensorism-gen 0.2.0

Multidimensional arrays with bounds included in the type system.
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

//! Macro for handling arrays with multiple indexes.
//!
//! This crate should not be used directly. Instead, use the `tensorism` crate.
//! It re-exports the items defined here and provides additional functionality.
extern crate proc_macro;
#[macro_use]
extern crate quote;

use proc_macro2::{Literal, TokenStream, TokenTree};

mod analysis;
mod model;
mod production;
mod unification;

use quote::ToTokens;

use crate::analysis::{inspection::inspect, top_group};

fn simplify(text: &str) -> String {
    let mut result = String::new();
    text.split('\n').map(|s| s.trim()).for_each(|s| {
        result.push_str(s);
        result.push(' ')
    });
    result
}

/// Macro that generate a new `ndarray::Array` by evaluating a special domain-specific language used for its argument.
/// See the `tensorism` crate for documentation and examples.
#[proc_macro]
pub fn new_ndarray(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    match syn::parse2::<crate::model::lambda::RicciGroup>(input.into()) {
        Err(error) => {
            let message = format!("Failed to parse input: {}", error);
            quote! { compile_error!(#message) }.into()
        }
        Ok(group) => match inspect(group) {
            Err(error) => {
                let message = format!("Index issues: {}", error);
                quote! { compile_error!(#message) }.into()
            }
            Ok((top_group, mapping)) => production::produce(top_group, mapping).into(),
        },
    }
}

#[doc(hidden)]
#[proc_macro]
pub fn format_new_ndarray(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    match syn::parse2::<crate::model::lambda::RicciGroup>(input.into()) {
        Err(error) => {
            let message = format!("Failed to parse input: {}", error);
            quote! { compile_error!(#message) }.into()
        }
        Ok(group) => match inspect(group) {
            Err(error) => {
                let message = format!("Index issues: {}", error);
                quote! { compile_error!(#message) }.into()
            }
            Ok((top_group, mapping)) => {
                let output = production::produce(top_group, mapping);
                let string = simplify(&output.to_string());
                let mut output = TokenStream::new();
                TokenTree::Literal(Literal::string(string.as_str())).to_tokens(&mut output);
                output.into()
            }
        },
    }
}