memory: implement TryFrom<MemoryValue> for F

Author: tcoratger

crates/leanVm/src/core.rs

@@ -60,9 +60,9 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
                 .value_from_mem_or_constant(condition, &self.memory_manager)?;
 
             // A jump condition must be a field element.
-            let is_zero = condition_val.to_f()?.is_zero();
+            let f: F = condition_val.try_into()?;
 
-            if is_zero {
+            if f.is_zero() {
                 // **Condition is zero**: The jump is not taken. Advance the `pc` by one.
                 (*self.run_context.pc() + 1)?
             } else {
@@ -351,7 +351,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
         // Convert the state to an array of field
         let mut state_f: [F; DIMENSION * 2] = [F::ZERO; DIMENSION * 2];
         for i in 0..DIMENSION {
-            state_f[i] = state[i].to_f()?;
+            state_f[i] = state[i].try_into()?;
         }
 
         // Apply the Poseidon2 permutation to the state.

crates/leanVm/src/memory/val.rs

@@ -19,11 +19,13 @@ impl Default for MemoryValue {
     }
 }
 
-impl MemoryValue {
-    pub const fn to_f(&self) -> Result<F, MemoryError> {
-        match self {
-            Self::Address(_) => Err(MemoryError::ExpectedInteger),
-            Self::Int(f) => Ok(*f),
+impl TryFrom<MemoryValue> for F {
+    type Error = MemoryError;
+
+    fn try_from(value: MemoryValue) -> Result<Self, Self::Error> {
+        match value {
+            MemoryValue::Int(f) => Ok(f),
+            MemoryValue::Address(_) => Err(MemoryError::ExpectedInteger),
         }
     }
 }
@@ -124,14 +126,11 @@ mod tests {
         // Wrap it in a MemoryValue::Int variant
         let val: MemoryValue = MemoryValue::Int(field_elem);
 
-        // Call to_f()
-        let result = val.to_f();
-
-        // Assert it succeeds
-        assert!(result.is_ok());
+        // Call
+        let result: F = val.try_into().unwrap();
 
         // Assert the returned value is equal to the original
-        assert_eq!(result.unwrap(), field_elem);
+        assert_eq!(result, field_elem);
     }
 
     #[test]
@@ -145,8 +144,8 @@ mod tests {
         // Wrap it in a MemoryValue::Address variant
         let val: MemoryValue = MemoryValue::Address(addr);
 
-        // Call to_f()
-        let result = val.to_f();
+        // Call
+        let result: Result<F, MemoryError> = val.try_into();
 
         // Assert it fails
         assert!(result.is_err());