mathsys 9.0.0

The Natural Language of Math.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//^
//^ HEAD
//^

//> HEAD -> FLAGS
#![allow(unused_variables)]
#![allow(nonstandard_style)]
#![feature(try_trait_v2)]
#![feature(default_field_values)]
#![feature(if_let_guard)]

//> HEAD -> MODULES
pub mod prelude;
mod issues;
mod entry;
mod tokenizer;
mod parser;
mod solver;
mod syntax;
mod backends;
pub mod settings;

//> HEAD -> PRELUDE
use self::prelude::{
    Time, Duration, ARCH, OS, rustcv
};

//> HEAD -> LOCAL
use self::{
    syntax::Start,
    tokenizer::{
        token::ShallowToken,
        Tokenizer,
        MAXLEN
    },
    parser::Parser,
    solver::Solver,
    backends::Backends,
    issues::Issue,
    settings::Settings,
    entry::Target
};


//^
//^ PIPELINE
//^

//> PIPELINE -> VERSION
static VERSION: usize = 9;

//> PIPELINE -> BASE TRANSFORMERS
pub static TRANSFORMERS: Transformers = Transformers::new();

//> PIPELINE -> TRANSFORMERS
pub struct Transformers {
    tokenizer: Tokenizer,
    parser: Parser,
    solver: Solver
} impl Transformers {
    const fn new() -> Self {return Transformers {
        tokenizer: Tokenizer::new(),
        parser: Parser::new(),
        solver: Solver::new()
    }}
    pub fn run(&self, settings: &Settings) -> Vec<Run> {
        let mut time = Time::now();
        let mut results = Vec::new();
        for target in &settings.targets {
            results.push(Run {
                time: time.elapsed(),
                data: self.compute(target, settings)
            });
            time = Time::now();
        }
        return results;
    }
    fn compute(&self, target: &Target, settings: &Settings) -> Result<Data, Issue> {Ok(match target {
        Target::Help => return Err(Issue::GetHelp),
        Target::Version => Data::Version {
            mathsys: VERSION,
            rust: rustcv().minor,
            ..
        },
        Target::Tokens => {let tokens = self.tokens(settings)?; Data::Tokens {
            length: tokens.len(),
            percentage: tokens.len() as f32 / MAXLEN as f32,
            tokens: tokens,
            ..
        }},
        Target::Check => match self.start(settings) {
            Ok(start) => Data::Check,
            Err(issue) => return Err(issue)
        },
        Target::Ast => Data::Ast {
            start: self.start(settings)?
        },
        Target::Latex => Data::Latex {
            representation: self.start(settings)?.latex()
        }
    })}
    fn content(&self, settings: &Settings) -> Result<String, Issue> {settings.files.iter().next().ok_or(Issue::MissingFile)?.read()}
    fn tokens(&self, settings: &Settings) -> Result<Vec<ShallowToken>, Issue> {Ok(self.tokenizer.run(&self.content(settings)?, settings)?.into_iter().map(|token| token.fixate()).collect())}
    fn start(&self, settings: &Settings) -> Result<Start, Issue> {
        let content = self.content(settings)?;
        let mut start = self.solver.run(&self.parser.run(&self.tokenizer.run(&content, settings)?, settings))?;
        start.modules(self, settings)?;
        return Ok(start);
    }
}

//> PIPELINE -> RUN
pub struct Run {
    pub time: Duration,
    pub data: Result<Data, Issue>
}

//> PIPELINE -> DATA
pub enum Data {
    Version {
        mathsys: usize,
        architecture: &'static str = ARCH,
        os: &'static str = OS,
        rust: u64
    },
    Tokens {
        length: usize,
        percentage: f32,
        tokens: Vec<ShallowToken>,
        maximum: usize = MAXLEN
    },
    Check,
    Ast {
        start: Start
    },
    Latex {
        representation: String
    }
}