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

use super::{reference::Reference, Expression, IndexedAccessExpression};
use crate::interpreter::context::Context;
use anyhow::anyhow;

#[derive(Clone, Debug, PartialEq)]
pub enum Statement {
    Assignment(Reference, Expression),
    IndexedAssigment(IndexedAccessExpression, Expression),
    Expression(Expression),
}

impl Statement {
    pub(crate) fn execute(&self, context: &mut Context) -> anyhow::Result<Expression> {
        match self {
            Self::Assignment(reference, expression) => {
                let result = expression.execute(context)?;
                context.insert_or_update_in_heap(reference, result)?;
                Ok(Expression::Unit)
            }
            Self::IndexedAssigment(key, value) => match key.to_reference(context) {
                Ok(Expression::Reference(reference)) => {
                    let result = value.execute(context)?;
                    context.insert_or_update_in_heap(&reference, result)?;
                    Ok(Expression::Unit)
                }
                Ok(_) => Err(anyhow!("Cannot assign to expression {:?}", key)),
                err @ Err(_) => err,
            },
            Self::Expression(expression) => expression.execute(context),
        }
    }
}