ijzer_lib 0.1.1

Library for IJzer. Provides tools for tensors, parsing syntax tree of the IJ language and transpiling it to rust code.
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

//! Parses numbers and infers their type.
//! 
//! For example `1` is a number, and so is `1.0<f64>`. 
//! If no type is specified, the type is inferred to be `_`.
use super::ParseNode;

use crate::ast_node::{ASTContext, Node, TokenSlice};
use crate::operations::Operation;
use crate::tokens::Token;
use crate::types::IJType;
use anyhow::Result;
use std::rc::Rc;

pub struct NumberNode;
impl ParseNode for NumberNode {
    fn next_node(
        op: Token,
        slice: TokenSlice,
        context: &mut ASTContext,
    ) -> Result<(Rc<Node>, TokenSlice)> {
        let node_op = match op {
            Token::Number(n) => Operation::Number(n),
            _ => unreachable!(),
        };
        match context.get_token_at_index(slice.start) {
            Ok(Token::NumberType(n)) => {
                let slice = slice.move_start(1)?;
                Ok((
                    Rc::new(Node::new(
                        node_op,
                        vec![],
                        IJType::Number(Some(n.clone())),
                        vec![],
                        context,
                    )?),
                    slice,
                ))
            }
            _ => Ok((
                Rc::new(Node::new(
                    node_op,
                    vec![],
                    IJType::Number(None),
                    vec![],
                    context,
                )?),
                slice,
            )),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::parse_str_no_context;
    use crate::tokens::Number;

    #[test]
    fn test_number_node() -> Result<()> {
        let (node, _) = parse_str_no_context("1.0")?;
        assert_eq!(
            node.op,
            Operation::Number(Number {
                value: "1.0".to_string()
            })
        );
        assert_eq!(node.output_type, IJType::Number(None));
        let (node, _) = parse_str_no_context("1")?;
        assert_eq!(
            node.op,
            Operation::Number(Number {
                value: "1".to_string()
            })
        );
        assert_eq!(node.output_type, IJType::Number(None));
        Ok(())
    }

    #[test]
    fn test_number_node_type() -> Result<()> {
        let (node, _) = parse_str_no_context("1.0<_>")?;
        assert_eq!(
            node.op,
            Operation::Number(Number {
                value: "1.0".to_string()
            })
        );
        assert_eq!(node.output_type, IJType::Number(Some("_".to_string())));
        let (node, _) = parse_str_no_context("1.0<f64>")?;
        assert_eq!(
            node.op,
            Operation::Number(Number {
                value: "1.0".to_string()
            })
        );
        assert_eq!(node.output_type, IJType::Number(Some("f64".to_string())));
        let (node, _) = parse_str_no_context("1<i32>")?;
        assert_eq!(
            node.op,
            Operation::Number(Number {
                value: "1".to_string()
            })
        );
        assert_eq!(node.output_type, IJType::Number(Some("i32".to_string())));
        Ok(())
    }
}