lang: mv Expression to a dedicated file

Author: tcoratger

crates/leanVm/src/lang/boolean.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::lang::Expression;
+use crate::lang::expression::Expression;
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Boolean {

crates/leanVm/src/lang/const_expr.rs

@@ -4,7 +4,7 @@ use p3_field::PrimeCharacteristicRing;
 
 use crate::{
     Label,
-    lang::{ConstantValue, Expression, F, HighLevelOperation, SimpleExpr},
+    lang::{ConstantValue, F, HighLevelOperation, SimpleExpr, expression::Expression},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

crates/leanVm/src/lang/expression.rs

@@ -0,0 +1,74 @@
+use std::fmt;
+
+use crate::lang::{F, HighLevelOperation, SimpleExpr, Var};
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Expression {
+    Value(SimpleExpr),
+    ArrayAccess {
+        array: Var,
+        index: Box<Expression>,
+    },
+    Binary {
+        left: Box<Self>,
+        operation: HighLevelOperation,
+        right: Box<Self>,
+    },
+}
+
+impl Expression {
+    #[must_use]
+    pub fn naive_eval(&self) -> Option<F> {
+        self.eval_with(
+            &|value: &SimpleExpr| value.as_constant()?.naive_eval(),
+            &|_, _| None,
+        )
+    }
+
+    pub fn eval_with<ValueFn, ArrayFn>(&self, value_fn: &ValueFn, array_fn: &ArrayFn) -> Option<F>
+    where
+        ValueFn: Fn(&SimpleExpr) -> Option<F>,
+        ArrayFn: Fn(&Var, F) -> Option<F>,
+    {
+        match self {
+            Self::Value(value) => value_fn(value),
+            Self::ArrayAccess { array, index } => {
+                array_fn(array, index.eval_with(value_fn, array_fn)?)
+            }
+            Self::Binary {
+                left,
+                operation,
+                right,
+            } => Some(operation.eval(
+                left.eval_with(value_fn, array_fn)?,
+                right.eval_with(value_fn, array_fn)?,
+            )),
+        }
+    }
+}
+
+impl From<SimpleExpr> for Expression {
+    fn from(value: SimpleExpr) -> Self {
+        Self::Value(value)
+    }
+}
+
+impl From<Var> for Expression {
+    fn from(var: Var) -> Self {
+        Self::Value(var.into())
+    }
+}
+
+impl fmt::Display for Expression {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Value(val) => write!(f, "{val}"),
+            Self::ArrayAccess { array, index } => write!(f, "{array}[{index}]"),
+            Self::Binary {
+                left,
+                operation,
+                right,
+            } => write!(f, "({left} {operation} {right})"),
+        }
+    }
+}

crates/leanVm/src/lang/mod.rs

@@ -1,80 +1,26 @@
 use std::fmt;
 
-
 use crate::{
     bytecode::precompiles::Precompile,
     constant::F,
     intermediate_bytecode::HighLevelOperation,
-    lang::{boolean::Boolean, constant_value::ConstantValue, simple_expr::SimpleExpr},
+    lang::{
+        boolean::Boolean, constant_value::ConstantValue, expression::Expression,
+        simple_expr::SimpleExpr,
+    },
 };
 
 pub mod boolean;
 pub mod const_expr;
 pub mod constant_value;
+pub mod expression;
 pub mod function;
 pub mod program;
 pub mod simple_expr;
 
 pub type Var = String;
 pub type ConstMallocLabel = usize;
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Expression {
-    Value(SimpleExpr),
-    ArrayAccess {
-        array: Var,
-        index: Box<Expression>,
-    },
-    Binary {
-        left: Box<Self>,
-        operation: HighLevelOperation,
-        right: Box<Self>,
-    },
-}
-
-impl From<SimpleExpr> for Expression {
-    fn from(value: SimpleExpr) -> Self {
-        Self::Value(value)
-    }
-}
-
-impl From<Var> for Expression {
-    fn from(var: Var) -> Self {
-        Self::Value(var.into())
-    }
-}
-
-impl Expression {
-    #[must_use]
-    pub fn naive_eval(&self) -> Option<F> {
-        self.eval_with(
-            &|value: &SimpleExpr| value.as_constant()?.naive_eval(),
-            &|_, _| None,
-        )
-    }
-
-    pub fn eval_with<ValueFn, ArrayFn>(&self, value_fn: &ValueFn, array_fn: &ArrayFn) -> Option<F>
-    where
-        ValueFn: Fn(&SimpleExpr) -> Option<F>,
-        ArrayFn: Fn(&Var, F) -> Option<F>,
-    {
-        match self {
-            Self::Value(value) => value_fn(value),
-            Self::ArrayAccess { array, index } => {
-                array_fn(array, index.eval_with(value_fn, array_fn)?)
-            }
-            Self::Binary {
-                left,
-                operation,
-                right,
-            } => Some(operation.eval(
-                left.eval_with(value_fn, array_fn)?,
-                right.eval_with(value_fn, array_fn)?,
-            )),
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Line {
     Assignment {
@@ -131,20 +77,6 @@ pub enum Line {
     },
 }
 
-impl fmt::Display for Expression {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Value(val) => write!(f, "{val}"),
-            Self::ArrayAccess { array, index } => write!(f, "{array}[{index}]"),
-            Self::Binary {
-                left,
-                operation,
-                right,
-            } => write!(f, "({left} {operation} {right})"),
-        }
-    }
-}
-
 impl Line {
     #[allow(clippy::too_many_lines)]
     fn to_string_with_indent(&self, indent: usize) -> String {