runtime/stdlib: Refactor to simplify conversions

- Use the new `impl_simple_into_value` macro in more places

- Implement Into<Value> for any Into<Array> type

- Implement FromIterator for Array/Value

- Utilize conversion traits where possible

Author: loop-ghost5rty

src/macros.rs

@@ -86,29 +86,18 @@ macro_rules! impl_simple_to_value {
         }
     };
 }
-macro_rules! impl_simple_to_array {
-    ($src:ty, $var:tt, $expr:expr) => {
-        impl_simple_to_value!($src, $var, Value::array_of($expr));
-    };
-}
-macro_rules! impl_simple_iter_to_array {
-    ($src:ty, $var:tt, $expr:expr) => {
-        impl_simple_to_value!($src, $var, Array($expr.map(Into::into).collect()));
-    };
-}
-
 macro_rules! add_tags {
     ($struct:ident, $tags:tt, $($field:ident),+) => {
         $tags.extend([$(
-            Value::array_of((stringify!($field), $struct.$field))
+            (stringify!($field), $struct.$field).into()
         ),+]);
     };
 }
 macro_rules! add_opt_tags {
     ($struct:ident, $tags:tt, $($field:ident),+) => {
         $(
             if let Some(val) = $struct.$field {
-                $tags.push(Value::array_of((stringify!($field), val)));
+                $tags.push((stringify!($field), val).into());
             }
         )+
     };

src/runtime/array.rs

@@ -1,5 +1,6 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::convert::{TryFrom, TryInto};
+use std::iter::FromIterator;
 use std::{fmt, mem, ops, vec};
 
 use crate::runtime::{Error, FieldAccess, FromValue, Result, Value};
@@ -165,6 +166,13 @@ impl IntoIterator for Array {
     }
 }
 
+// Generic conversion from an iterator of any convertible type into an Array
+impl<V: Into<Value>> FromIterator<V> for Array {
+    fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self {
+        Self(iter.into_iter().map(Into::into).collect())
+    }
+}
+
 // Generic conversion from 1/2/3/4-tuples of any convertible type into an Array
 impl<A: Into<Value>> From<(A,)> for Array {
     fn from((a,): (A,)) -> Self {
@@ -189,18 +197,13 @@ impl<A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>> From<(A, B,
 
 // Generic conversion from native set types into Array
 impl<T: Into<Value>> From<Vec<T>> for Array {
-    fn from(value: Vec<T>) -> Self {
-        Array(value.into_iter().map(Into::into).collect())
+    fn from(vec: Vec<T>) -> Self {
+        Array::from_iter(vec)
     }
 }
 impl<K: Into<Value>, V: Into<Value>> From<BTreeMap<K, V>> for Array {
-    fn from(value: BTreeMap<K, V>) -> Self {
-        Array(
-            value
-                .into_iter()
-                .map(|(k, v)| Value::array_of((k, v)))
-                .collect(),
-        )
+    fn from(map: BTreeMap<K, V>) -> Self {
+        Array::from_iter(map)
     }
 }
 

src/runtime/mod.rs

@@ -45,7 +45,9 @@ impl Execute for ast::Assign {
 impl Execute for ast::FnDef {
     fn exec(&self, scope: &ScopeRef<Mutable>) -> Result<()> {
         let func = Function::from_def(self.clone(), scope.as_readonly());
-        scope.borrow_mut().set(self.ident.clone(), func)
+        scope
+            .borrow_mut()
+            .set(self.ident.clone(), Value::function(func))
     }
 }
 
@@ -258,7 +260,7 @@ impl FieldAccess for Value {
 impl Evaluate for ast::FnExpr {
     fn eval(&self, scope: &ScopeRef) -> Result<Value> {
         let func = Function::from_expr(self.clone(), scope.make_ref());
-        Ok(func.into())
+        Ok(Value::function(func))
     }
 }
 

src/runtime/scope.rs

@@ -43,7 +43,7 @@ impl Scope {
     pub fn set_fn<K: Into<Ident>>(&mut self, key: K, pt: NativeFunctionPt) -> Result<()> {
         let key = key.into();
         let func = NativeFunction::new(pt, Some(key.clone()));
-        self.set(key, func)
+        self.set(key, Value::function(func))
     }
 
     /// Get a builtin variable, which must be available in scope

src/runtime/value.rs

@@ -63,44 +63,25 @@ pub struct Symbol {
 // Value conversions
 //
 
-// From primitive numbers to Value
-impl From<i64> for Value {
-    fn from(n: i64) -> Value {
-        Number::Int(n).into()
-    }
-}
-impl From<f64> for Value {
-    fn from(n: f64) -> Value {
-        Number::Float(n).into()
-    }
-}
-impl From<u32> for Value {
-    fn from(num: u32) -> Value {
-        (num as i64).into()
-    }
-}
-impl From<i32> for Value {
-    fn from(num: i32) -> Value {
-        (num as i64).into()
-    }
-}
-impl From<usize> for Value {
-    fn from(num: usize) -> Value {
-        // TODO this should use TryFrom
-        Number::Int(num.try_into().unwrap()).into()
-    }
-}
+// From primitive types to Value
+impl_simple_to_value!(i64, n, Number::Int(n));
+impl_simple_to_value!(f64, n, Number::Float(n));
+impl_simple_to_value!(u32, n, n as i64);
+impl_simple_to_value!(i32, n, n as i64);
+impl_simple_to_value!(usize, n, i64::try_from(n).unwrap()); // XXX should not panic
+impl_simple_to_value!(&str, s, s.to_string());
+
 impl TryFrom<u64> for Value {
     type Error = Error;
     fn try_from(num: u64) -> Result<Self> {
         Ok(Value::Number(Number::Int(num.try_into()?)))
     }
 }
 
-// From NativeFunction/UserFunction to Value
-impl<T: Into<Function>> From<T> for Value {
+// From any Into<Array> type to Value
+impl<T: Into<Array>> From<T> for Value {
     fn from(f: T) -> Self {
-        Value::Function(f.into())
+        Value::Array(f.into())
     }
 }
 
@@ -109,7 +90,6 @@ impl_from_variant!(bool, Value, Bool);
 impl_from_variant!(Number, Value);
 impl_from_variant!(String, Value);
 impl_from_variant!(Vec<u8>, Value, Bytes);
-impl_from_variant!(Array, Value);
 impl_from_variant!(Symbol, Value);
 impl_from_variant!(Policy, Value);
 impl_from_variant!(Descriptor, Value);
@@ -123,12 +103,6 @@ impl_from_variant!(TaprootSpendInfo, Value, TapInfo);
 impl_from_variant!(WshScript, Value);
 impl_from_variant!(Psbt, Value);
 
-impl From<&str> for Value {
-    fn from(s: &str) -> Self {
-        Value::String(s.to_string())
-    }
-}
-
 // From Value to the underlying enum inner type
 // Simple extraction of the enum variant, with no specialized type coercion logic
 impl_simple_into_variant!(bool, Bool, into_bool, NotBool);
@@ -138,6 +112,7 @@ impl_simple_into_variant!(Function, Function, into_fn, NotFn);
 impl_simple_into_variant!(String, String, into_string, NotString);
 impl_simple_into_variant!(WshScript, WshScript, into_wsh_script, NotWshScript);
 
+
 // From Value to f64 primitive, with auto-coercion for integers
 impl TryFrom<Value> for f64 {
     type Error = Error;
@@ -310,23 +285,6 @@ impl_delegate_array_conv!((A, ), A: FromValue);
 impl_delegate_array_conv!((A, B), A: FromValue, B: FromValue);
 impl_delegate_array_conv!((A, B, C), A: FromValue, B: FromValue, C: FromValue);
 
-// Generic conversion from sets into a Value
-impl<A: Into<Value>, B: Into<Value>> From<(A, B)> for Value {
-    fn from(value: (A, B)) -> Self {
-        Value::Array(value.into())
-    }
-}
-impl<T: Into<Value>> From<Vec<T>> for Value {
-    fn from(value: Vec<T>) -> Self {
-        Value::Array(value.into())
-    }
-}
-impl<K: Into<Value>, V: Into<Value>> From<BTreeMap<K, V>> for Value {
-    fn from(value: BTreeMap<K, V>) -> Self {
-        Value::Array(value.into())
-    }
-}
-
 //
 // Value impl
 //
@@ -421,8 +379,15 @@ impl Value {
     pub fn array(elements: Vec<Value>) -> Self {
         Value::Array(Array(elements))
     }
-    pub fn array_of(array: impl Into<Array>) -> Self {
-        Value::Array(array.into())
+
+    pub fn function(func: impl Into<Function>) -> Self {
+        Value::Function(func.into())
+    }
+}
+
+impl<V: Into<Value>> std::iter::FromIterator<V> for Value {
+    fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self {
+        Array::from_iter(iter).into()
     }
 }
 

src/stdlib/btc.rs

@@ -76,8 +76,7 @@ pub struct WshScript(pub ScriptBuf);
 impl Evaluate for ast::BtcAmount {
     fn eval(&self, scope: &ScopeRef) -> Result<Value> {
         let amount_n = self.0.eval(scope)?.into_f64()?;
-        let amount = SignedAmount::from_float_in(amount_n, self.1)?;
-        Ok(Value::from(amount.to_sat()))
+        Ok(SignedAmount::from_float_in(amount_n, self.1)?.into())
     }
 }
 
@@ -474,17 +473,23 @@ impl TryFrom<Value> for Witness {
 impl_simple_to_value!(Version, ver, ver.0);
 impl_simple_to_value!(Sequence, seq, seq.to_consensus_u32());
 impl_simple_to_value!(AbsLockTime, time, time.to_consensus_u32());
-impl_simple_to_array!(OutPoint, outpoint, (outpoint.txid, outpoint.vout));
-impl_simple_iter_to_array!(Witness, wit, wit.to_vec().into_iter());
-impl_simple_to_array!(
+impl_simple_to_value!(OutPoint, outpoint, (outpoint.txid, outpoint.vout));
+impl_simple_to_value!(Witness, wit, wit.to_vec());
+impl_simple_to_value!(SignedAmount, amt, amt.to_sat());
+// Panics for out-of-range `Amount`s (i64 can represent up to ~92 billion BTC, ~4400x more than can exists),
+// which should be impossible to construct within Minsc (but can be passed from Rust code).
+// Uses to_signed() to convert from u64 to i64 with a useful OutOfRangeError message.
+impl_simple_to_value!(Amount, amt, amt.to_signed().unwrap());
+
+impl_simple_to_value!(
     bitcoin::transaction::TxOut,
     txout,
     (
         ("script_pubkey", txout.script_pubkey),
-        ("amount", i64::try_from(txout.value.to_sat()).unwrap()),
+        ("amount", txout.value),
     )
 );
-impl_simple_to_array!(
+impl_simple_to_value!(
     bitcoin::transaction::TxIn,
     txin,
     (
@@ -501,15 +506,26 @@ impl_simple_to_value!(Txid, txid, {
     txid.reverse();
     txid
 });
+// Panics for out-of-range `Weight`s, which should be impossible to construct
+impl_simple_to_value!(
+    bitcoin::Weight,
+    w,
+    i64::try_from(w.to_wu()).expect("out of range weight")
+);
 
 // Transaction fields accessors
 impl FieldAccess for Transaction {
     fn get_field(self, field: &Value) -> Option<Value> {
         Some(match field.as_str()? {
             "version" => self.version.into(),
-            "lock_time" => self.lock_time.into(),
-            "input" | "inputs" => Value::array_of(self.input),
-            "output" | "outputs" => Value::array_of(self.output),
+            "locktime" => self.lock_time.into(),
+            "input" | "inputs" => self.input.into(),
+            "output" | "outputs" => self.output.into(),
+
+            "txid" => self.compute_txid().into(),
+            "weight" => self.weight().into(),
+            "vsize" => self.vsize().into(),
+            "size" => self.total_size().into(),
             _ => {
                 return None;
             }

src/stdlib/crypto.rs

@@ -90,8 +90,6 @@ pub mod fns {
         } else {
             EC.sign_schnorr_no_aux_rand(&msg, &keypair)
         }
-        .serialize()
-        .to_vec()
         .into())
     }
 
@@ -156,6 +154,8 @@ impl TryFrom<Value> for bitcoin::ecdsa::Signature {
 
 // Convert from native types to Value
 impl_simple_to_value!(bitcoin::ecdsa::Signature, sig, sig.to_vec());
+impl_simple_to_value!(secp256k1::schnorr::Signature, sig, sig.serialize().to_vec());
+impl_simple_to_value!(secp256k1::Message, msg, msg[..].to_vec());
 
 // Convert Value <-> Hash types
 macro_rules! impl_hash_conv {