algorithmify 0.1.1

Create specifications for algorithms defined using 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

use crate::{interpreter::context::Context, Expression};

use super::Statement;

#[derive(Debug, Clone, PartialEq)]
pub enum Condition {
    If(If),
}

impl Condition {
    pub fn execute(&self, context: &mut Context) -> anyhow::Result<Expression> {
        match self {
            Self::If(condition) => condition.execute(context),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct If {
    pub statements: Vec<Statement>,
    pub else_clause: Option<Expression>,
    pub condition: Expression,
}

impl If {
    fn execute(&self, context: &mut Context) -> Result<Expression, anyhow::Error> {
        let mut result = Expression::Unit;

        context.push_stack();

        if let Expression::Bool(true) = self.condition.execute(context)? {
            for statement in &self.statements {
                result = statement.execute(context)?;
            }
        } else {
            if let Some(else_clause) = &self.else_clause {
                result = else_clause.execute(context)?;
            }
        }

        context.pop_stack();

        Ok(result)
    }
}