rust: add From trait and as_*() helpers on Value

bindings/rust/src/lib.rs

@@ -60,8 +60,66 @@ impl Module {
     }
 }
 
+// TODO: add a proper wrapper (enum type for Value, and Result<Value, Trap> for ExecutionResult)
+
 pub type Value = sys::FizzyValue;
 
+impl Value {
+    pub fn as_i32(&self) -> i32 {
+        unsafe { self.i64 as i32 }
+    }
+    pub fn as_u32(&self) -> u32 {
+        unsafe { self.i64 as u32 }
+    }
+    pub fn as_i64(&self) -> i64 {
+        unsafe { self.i64 as i64 }
+    }
+    pub fn as_u64(&self) -> u64 {
+        unsafe { self.i64 }
+    }
+    pub fn as_f32(&self) -> f32 {
+        unsafe { self.f32 }
+    }
+    pub fn as_f64(&self) -> f64 {
+        unsafe { self.f64 }
+    }
+}
+
+impl From<i32> for Value {
+    fn from(v: i32) -> Self {
+        Value { i64: v as u64 }
+    }
+}
+
+impl From<u32> for Value {
+    fn from(v: u32) -> Self {
+        Value { i64: v as u64 }
+    }
+}
+
+impl From<i64> for Value {
+    fn from(v: i64) -> Self {
+        Value { i64: v as u64 }
+    }
+}
+
+impl From<u64> for Value {
+    fn from(v: u64) -> Self {
+        Value { i64: v }
+    }
+}
+impl From<f32> for Value {
+    fn from(v: f32) -> Self {
+        Value { i64: v as u64 }
+    }
+}
+
+impl From<f64> for Value {
+    fn from(v: f64) -> Self {
+        Value { i64: v as u64 }
+    }
+}
+
 pub type ExecutionResult = sys::FizzyExecutionResult;
 
 impl Instance {
@@ -122,16 +180,19 @@ mod tests {
         let result = instance.execute(1, &[]);
         assert!(!result.trapped);
         assert!(result.has_value);
-        unsafe {
-            assert_eq!(result.value.i64, 42);
-        } // FIXME: this is actually i32
+        assert_eq!(result.value.as_i32(), 42);
+
+        // Explicit type specification
+        let result = instance.execute(2, &[(42 as i32).into(), (2 as i32).into()]);
+        assert!(!result.trapped);
+        assert!(result.has_value);
+        assert_eq!(result.value.as_i32(), 21);
 
-        let result = instance.execute(2, &[Value { i64: 42 }, Value { i64: 2 }]);
+        // Implicit i64 types (even though the code expects i32)
+        let result = instance.execute(2, &[42.into(), 2.into()]);
         assert!(!result.trapped);
         assert!(result.has_value);
-        unsafe {
-            assert_eq!(result.value.i64, 21);
-        } // FIXME: this is actually i32
+        assert_eq!(result.value.as_i32(), 21);
 
         let result = instance.execute(3, &[]);
         assert!(result.trapped);