Change parse_num to accept generic

Author: sanket1729

src/descriptor/sortedmulti.rs

@@ -78,7 +78,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         if tree.args.is_empty() {
             return Err(errstr("no arguments given for sortedmulti"));
         }
-        let k = expression::parse_num(tree.args[0].name)?;
+        let k = expression::parse_num::<u32>(tree.args[0].name)?;
         if k > (tree.args.len() - 1) as u32 {
             return Err(errstr(
                 "higher threshold than there were keys in sortedmulti",

src/expression.rs

@@ -230,7 +230,7 @@ impl<'a> Tree<'a> {
 }
 
 /// Parse a string as a u32, for timelocks or thresholds
-pub fn parse_num(s: &str) -> Result<u32, Error> {
+pub fn parse_num<T: FromStr>(s: &str) -> Result<T, Error> {
     if s.len() > 1 {
         let ch = s.chars().next().unwrap();
         if !('1'..='9').contains(&ch) {
@@ -239,7 +239,7 @@ pub fn parse_num(s: &str) -> Result<u32, Error> {
             ));
         }
     }
-    u32::from_str(s).map_err(|_| errstr(s))
+    T::from_str(s).map_err(|_| errstr(s))
 }
 
 /// Attempts to parse a terminal expression
@@ -292,11 +292,11 @@ mod tests {
 
     #[test]
     fn test_parse_num() {
-        assert!(parse_num("0").is_ok());
-        assert!(parse_num("00").is_err());
-        assert!(parse_num("0000").is_err());
-        assert!(parse_num("06").is_err());
-        assert!(parse_num("+6").is_err());
-        assert!(parse_num("-6").is_err());
+        assert!(parse_num::<u32>("0").is_ok());
+        assert!(parse_num::<u32>("00").is_err());
+        assert!(parse_num::<u32>("0000").is_err());
+        assert!(parse_num::<u32>("06").is_err());
+        assert!(parse_num::<u32>("+6").is_err());
+        assert!(parse_num::<u32>("-6").is_err());
     }
 }

src/miniscript/astelem.rs

@@ -589,10 +589,10 @@ impl_from_tree!(
                 expression::terminal(&top.args[0], |x| Pk::Hash::from_str(x).map(Terminal::PkH))
             }
             ("after", 1) => expression::terminal(&top.args[0], |x| {
-                expression::parse_num(x).map(Terminal::After)
+                expression::parse_num::<u32>(x).map(Terminal::After)
             }),
             ("older", 1) => expression::terminal(&top.args[0], |x| {
-                expression::parse_num(x).map(Terminal::Older)
+                expression::parse_num::<u32>(x).map(Terminal::Older)
             }),
             ("sha256", 1) => expression::terminal(&top.args[0], |x| {
                 Pk::Sha256::from_str(x).map(Terminal::Sha256)
@@ -634,7 +634,7 @@ impl_from_tree!(
                 if n == 0 {
                     return Err(errstr("no arguments given"));
                 }
-                let k = expression::terminal(&top.args[0], expression::parse_num)? as usize;
+                let k = expression::terminal(&top.args[0], expression::parse_num::<u32>)? as usize;
                 if k > n - 1 {
                     return Err(errstr("higher threshold than there are subexpressions"));
                 }
@@ -653,7 +653,7 @@ impl_from_tree!(
                 if n == 0 {
                     return Err(errstr("no arguments given"));
                 }
-                let k = expression::terminal(&top.args[0], expression::parse_num)? as usize;
+                let k = expression::terminal(&top.args[0], expression::parse_num::<u32>)? as usize;
                 if k > n - 1 {
                     return Err(errstr("higher threshold than there were keys in multi"));
                 }

src/policy/concrete.rs

@@ -754,7 +754,7 @@ impl_block_str!(
                 if !allow_prob {
                     return Err(Error::AtOutsideOr(top.name.to_owned()));
                 }
-                frag_prob = expression::parse_num(prob)? as usize;
+                frag_prob = expression::parse_num::<u32>(prob)? as usize;
                 frag_name = name;
             }
             (Some(_), Some(_), Some(_)) => {
@@ -820,7 +820,7 @@ impl_block_str!(
                     return Err(Error::PolicyError(PolicyError::IncorrectThresh));
                 }
 
-                let thresh = expression::parse_num(top.args[0].name)?;
+                let thresh = expression::parse_num::<u32>(top.args[0].name)?;
                 if thresh >= nsubs || thresh == 0 {
                     return Err(Error::PolicyError(PolicyError::IncorrectThresh));
                 }

src/policy/semantic.rs

@@ -333,10 +333,10 @@ impl_from_tree!(
                 Pk::Hash::from_str(pk).map(Policy::KeyHash)
             }),
             ("after", 1) => expression::terminal(&top.args[0], |x| {
-                expression::parse_num(x).map(Policy::After)
+                expression::parse_num::<u32>(x).map(Policy::After)
             }),
             ("older", 1) => expression::terminal(&top.args[0], |x| {
-                expression::parse_num(x).map(Policy::Older)
+                expression::parse_num::<u32>(x).map(Policy::Older)
             }),
             ("sha256", 1) => expression::terminal(&top.args[0], |x| {
                 Pk::Sha256::from_str(x).map(Policy::Sha256)
@@ -379,7 +379,7 @@ impl_from_tree!(
                     return Err(errstr(top.args[0].args[0].name));
                 }
 
-                let thresh = expression::parse_num(top.args[0].name)?;
+                let thresh = expression::parse_num::<u32>(top.args[0].name)?;
 
                 // thresh(1) and thresh(n) are disallowed in semantic policies
                 if thresh <= 1 || thresh >= (nsubs as u32 - 1) {