tr: introduce TapTree:leaf constructor

This constructor will be part of the new API introduced in the following
"flatten TapTree" commit. To reduce the diff of that commit, introduce it
now.

Author: apoelstra

src/descriptor/tr/mod.rs

@@ -456,7 +456,7 @@ impl<Pk: FromStrKey> crate::expression::FromTree for Tr<Pk> {
                     return Err(Error::NonTopLevel(format!("{:?}", script)));
                 };
 
-                tree_stack.push(node.parent().unwrap(), TapTree::Leaf(Arc::new(script)))?;
+                tree_stack.push(node.parent().unwrap(), TapTree::leaf(script))?;
                 tap_tree_iter.skip_descendants();
             }
         }

src/descriptor/tr/taptree.rs

@@ -46,6 +46,9 @@ pub enum TapTree<Pk: MiniscriptKey> {
 }
 
 impl<Pk: MiniscriptKey> TapTree<Pk> {
+    /// Creates a `TapTree` leaf from a Miniscript.
+    pub fn leaf<A: Into<Arc<Miniscript<Pk, Tap>>>>(ms: A) -> Self { TapTree::Leaf(ms.into()) }
+
     /// Creates a `TapTree` by combining `left` and `right` tree nodes.
     pub fn combine(left: TapTree<Pk>, right: TapTree<Pk>) -> Result<Self, TapTreeDepthError> {
         let height = 1 + cmp::max(left.height(), right.height());

src/policy/concrete.rs

@@ -589,7 +589,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
             .collect()
     }
 
-    /// Gets the number of [TapLeaf](`TapTree::Leaf`)s considering exhaustive root-level [`Policy::Or`]
+    /// Gets the number of [TapLeaf](`TapTree::leaf`)s considering exhaustive root-level [`Policy::Or`]
     /// and [`Policy::Thresh`] disjunctions for the `TapTree`.
     #[cfg(feature = "compiler")]
     fn num_tap_leaves(&self) -> usize { self.tapleaf_probability_iter().count() }
@@ -957,7 +957,7 @@ impl<Pk: FromStrKey> expression::FromTree for Policy<Pk> {
 fn with_huffman_tree<Pk: MiniscriptKey>(ms: Vec<(OrdF64, Miniscript<Pk, Tap>)>) -> TapTree<Pk> {
     let mut node_weights = BinaryHeap::<(Reverse<OrdF64>, TapTree<Pk>)>::new();
     for (prob, script) in ms {
-        node_weights.push((Reverse(prob), TapTree::Leaf(Arc::new(script))));
+        node_weights.push((Reverse(prob), TapTree::leaf(script)));
     }
     assert_ne!(node_weights.len(), 0, "empty Miniscript compilation");
     while node_weights.len() > 1 {

src/policy/mod.rs

@@ -375,7 +375,7 @@ mod tests {
             let descriptor = policy.compile_tr(Some(unspendable_key.clone())).unwrap();
 
             let ms_compilation: Miniscript<String, Tap> = ms_str!("multi_a(2,A,B,C,D)");
-            let tree: TapTree<String> = TapTree::Leaf(Arc::new(ms_compilation));
+            let tree: TapTree<String> = TapTree::leaf(ms_compilation);
             let expected_descriptor =
                 Descriptor::new_tr(unspendable_key.clone(), Some(tree)).unwrap();
             assert_eq!(descriptor, expected_descriptor);
@@ -391,8 +391,8 @@ mod tests {
             let right_ms_compilation: Arc<Miniscript<String, Tap>> =
                 Arc::new(ms_str!("and_v(v:pk(A),pk(B))"));
 
-            let left = TapTree::Leaf(left_ms_compilation);
-            let right = TapTree::Leaf(right_ms_compilation);
+            let left = TapTree::leaf(left_ms_compilation);
+            let right = TapTree::leaf(right_ms_compilation);
             let tree = TapTree::combine(left, right).unwrap();
 
             let expected_descriptor =
@@ -454,7 +454,7 @@ mod tests {
                 .into_iter()
                 .map(|x| {
                     let leaf_policy: Concrete<String> = policy_str!("{}", x);
-                    TapTree::Leaf(Arc::from(leaf_policy.compile::<Tap>().unwrap()))
+                    TapTree::leaf(leaf_policy.compile::<Tap>().unwrap())
                 })
                 .collect::<Vec<_>>();