f expression Arc

Author: apoelstra

src/expression.rs

@@ -8,13 +8,15 @@ use core::str::FromStr;
 use crate::prelude::*;
 use crate::{errstr, Error, MAX_RECURSION_DEPTH};
 
+use sync::Arc;
+
 #[derive(Debug)]
 /// A token of the form `x(...)` or `x`
 pub struct Tree<'a> {
     /// The name `x`
     name: &'a str,
     /// The comma-separated contents of the `(...)`, if any
-    args: Vec<Tree<'a>>,
+    args: Arc<[Tree<'a>]>,
 }
 // or_b(pk(A),pk(B))
 //
@@ -153,29 +155,26 @@ impl<'a> Tree<'a> {
             Found::Nothing => Ok((
                 Tree {
                     name: sl,
-                    args: vec![],
+                    args: Arc::new([]),
                 },
                 "",
             )),
             // Terminal
             Found::Comma(n) | Found::RBracket(n) => Ok((
                 Tree {
                     name: &sl[..n],
-                    args: vec![],
+                    args: Arc::new([]),
                 },
                 &sl[n..],
             )),
             // Function call
             Found::LBracket(n) => {
-                let mut ret = Tree {
-                    name: &sl[..n],
-                    args: vec![],
-                };
+                let mut args = vec![];
 
                 sl = &sl[n + 1..];
                 loop {
                     let (arg, new_sl) = Tree::from_slice_delim(sl, depth + 1, delim)?;
-                    ret.args.push(arg);
+                    args.push(arg);
 
                     if new_sl.is_empty() {
                         return Err(Error::ExpectedChar(closing_delim(delim)));
@@ -193,6 +192,10 @@ impl<'a> Tree<'a> {
                         }
                     }
                 }
+                let ret = Tree {
+                    name: &sl[..n],
+                    args: Arc::from(args),
+                };
                 Ok((ret, sl))
             }
         }
@@ -230,11 +233,11 @@ impl<'a> Tree<'a> {
             if !rest.contains(',') {
                 let internal_key = Tree {
                     name: rest,
-                    args: vec![],
+                    args: Arc::new([]),
                 };
                 return Ok(Tree {
                     name: "tr",
-                    args: vec![internal_key],
+                    args: Arc::from([internal_key]),
                 });
             }
             // use str::split_once() method to refactor this when compiler version bumps up
@@ -243,19 +246,19 @@ impl<'a> Tree<'a> {
 
             let internal_key = Tree {
                 name: key,
-                args: vec![],
+                args: Arc::new([]),
             };
             if script.is_empty() {
                 return Ok(Tree {
                     name: "tr",
-                    args: vec![internal_key],
+                    args: Arc::from([internal_key]),
                 });
             }
             let (tree, rest) = Tree::from_slice_delim(script, 1, '{')?;
             if rest.is_empty() {
                 Ok(Tree {
                     name: "tr",
-                    args: vec![internal_key, tree],
+                    args: Arc::new([internal_key, tree]),
                 })
             } else {
                 Err(errstr(rest))