iter: introduce Ternary variant

It's lazy and takes some extra allocations to use Nary for the andor
combinator; introduce a dedicated Ternary variant for this.

This also means that Nary will be exclusively used for thresholds, which
should give us some more freedom to mess with it.

Author: apoelstra

src/iter/mod.rs

@@ -36,7 +36,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk,
             | OrD(ref left, ref right)
             | OrC(ref left, ref right)
             | OrI(ref left, ref right) => Tree::Binary(left, right),
-            AndOr(ref a, ref b, ref c) => Tree::Nary(Arc::from([a.as_ref(), b, c])),
+            AndOr(ref a, ref b, ref c) => Tree::Ternary(a, b, c),
             Thresh(ref thresh) => Tree::Nary(thresh.iter().map(Arc::as_ref).collect()),
         }
     }
@@ -62,7 +62,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for Arc<Miniscript<Pk, Ctx>
             | OrC(ref left, ref right)
             | OrI(ref left, ref right) => Tree::Binary(Arc::clone(left), Arc::clone(right)),
             AndOr(ref a, ref b, ref c) => {
-                Tree::Nary(Arc::from([Arc::clone(a), Arc::clone(b), Arc::clone(c)]))
+                Tree::Ternary(Arc::clone(a), Arc::clone(b), Arc::clone(c))
             }
             Thresh(ref thresh) => Tree::Nary(thresh.iter().map(Arc::clone).collect()),
         }

src/iter/tree.rs

@@ -20,6 +20,8 @@ pub enum Tree<T> {
     Unary(T),
     /// Combinator with two children.
     Binary(T, T),
+    /// Combinator with two children.
+    Ternary(T, T, T),
     /// Combinator with more than two children.
     Nary(Arc<[T]>),
 }
@@ -45,6 +47,7 @@ pub trait TreeLike: Clone + Sized {
             Tree::Nullary => 0,
             Tree::Unary(..) => 1,
             Tree::Binary(..) => 2,
+            Tree::Ternary(..) => 3,
             Tree::Nary(children) => children.len(),
         }
     }
@@ -58,6 +61,10 @@ pub trait TreeLike: Clone + Sized {
             (0, Tree::Binary(sub, _)) => Some(sub),
             (1, Tree::Binary(_, sub)) => Some(sub),
             (_, Tree::Binary(..)) => None,
+            (0, Tree::Ternary(sub, _, _)) => Some(sub),
+            (1, Tree::Ternary(_, sub, _)) => Some(sub),
+            (2, Tree::Ternary(_, _, sub)) => Some(sub),
+            (_, Tree::Ternary(..)) => None,
             (n, Tree::Nary(children)) => children.get(n).cloned(),
         }
     }
@@ -210,6 +217,11 @@ impl<T: TreeLike> Iterator for PreOrderIter<T> {
                 self.stack.push(right);
                 self.stack.push(left);
             }
+            Tree::Ternary(a, b, c) => {
+                self.stack.push(c);
+                self.stack.push(b);
+                self.stack.push(a);
+            }
             Tree::Nary(children) => {
                 self.stack.extend(children.iter().rev().cloned());
             }