change how bracket packs work

Author: kaikalii

src/check.rs

@@ -375,8 +375,10 @@ impl VirtualEnv {
                     self.handle_args_outputs(f.args().max(g.args()), f.outputs() + g.outputs());
                 }
                 Bracket => {
-                    let [f, g] = get_args(args)?;
-                    self.handle_args_outputs(f.args() + g.args(), f.outputs() + g.outputs());
+                    let (args, outputs) = args.iter().fold((0, 0), |(a, o), sn| {
+                        (a + sn.sig.args(), o + sn.sig.outputs())
+                    });
+                    self.handle_args_outputs(args, outputs);
                 }
                 Both => {
                     let [f] = get_args_nodes(args)?;
@@ -490,8 +492,10 @@ impl VirtualEnv {
                 }
                 UnFill | SidedFill(_) => self.fill(args)?,
                 UnBracket => {
-                    let [f, g] = get_args(args)?;
-                    self.handle_args_outputs(f.args() + g.args(), f.outputs() + g.outputs());
+                    let (args, outputs) = args.iter().fold((0, 0), |(a, o), sn| {
+                        (a + sn.sig.args(), o + sn.sig.outputs())
+                    });
+                    self.handle_args_outputs(args, outputs);
                 }
                 BothImpl(sub) | UnBothImpl(sub) => {
                     let [f] = get_args(args)?;

src/compile/data.rs

@@ -360,9 +360,8 @@ impl Compiler {
             .map(|f| f.init.as_ref().map(|sn| sn.sig.args()).unwrap_or(1))
             .sum();
         let mut node = if has_fields {
-            let mut inner = Node::default();
-            let mut sig = Signature::new(0, 0);
-            for field in fields.iter().rev() {
+            let mut field_nodes = EcoVec::with_capacity(fields.len());
+            for field in &fields {
                 let mut arg = if let Some(sn) = &field.init {
                     sn.clone()
                 } else {
@@ -378,18 +377,11 @@ impl Compiler {
                         Node::ImplPrim(ImplPrimitive::ValidateNonBoxedVariant, field.span).into(),
                     ));
                 }
-                if !inner.is_empty() {
-                    for _ in 0..arg.sig.args() {
-                        inner = Node::Mod(Primitive::Dip, eco_vec![SigNode::new(sig, inner)], span);
-                    }
-                }
-                sig.update_args(|a| a + arg.sig.args());
-                sig.update_outputs(|o| o + arg.sig.outputs());
-                inner.push(arg.node);
+                field_nodes.push(arg);
             }
             let mut node = Node::Array {
                 len: fields.len(),
-                inner: inner.into(),
+                inner: Node::Mod(Primitive::Bracket, field_nodes, span).into(),
                 boxed,
                 allow_ext: true,
                 prim: None,

src/compile/invert/un.rs

@@ -465,10 +465,12 @@ inverse!(
     }
 );
 
-inverse!(BracketPat, input, asm, Bracket, span, [f, g], {
-    let f_inv = f.un_inverse(asm)?;
-    let g_inv = g.un_inverse(asm)?;
-    Ok((input, ImplMod(UnBracket, eco_vec![f_inv, g_inv], span)))
+inverse!(BracketPat, input, asm, Bracket, span, args, {
+    let mut inv_args = EcoVec::with_capacity(args.len());
+    for sn in args {
+        inv_args.push(sn.un_inverse(asm)?);
+    }
+    Ok((input, ImplMod(UnBracket, inv_args, span)))
 });
 
 inverse!(OnPat, input, asm, On, span, [f], {

src/compile/modifier.rs

@@ -99,9 +99,7 @@ impl Compiler {
                 }
                 self.modified_impl(new, subscript)
             }
-            Modifier::Primitive(
-                Primitive::Fork | Primitive::Bracket | Primitive::Try | Primitive::Fill,
-            ) => {
+            Modifier::Primitive(Primitive::Fork | Primitive::Try | Primitive::Fill) => {
                 let mut branches = pack.lexical_order().cloned().rev();
                 let mut new = Modified {
                     modifier: modifier.clone(),
@@ -402,6 +400,7 @@ impl Compiler {
             }
         } else {
             let strict_args = match &modified.modifier.value {
+                Modifier::Primitive(Primitive::Bracket) => false,
                 Modifier::Primitive(_) => true,
                 Modifier::Macro(..) => false,
                 Modifier::Ref(name) => self
@@ -641,7 +640,7 @@ impl Compiler {
                             modified.modifier.span.clone().merge(sub.span),
                             format!(
                                 "Sided {}'s functions must both have 2 arguments, \
-                            but their signatures are {} and {}.",
+                                but their signatures are {} and {}.",
                                 Primitive::Bracket.format(),
                                 a.sig,
                                 b.sig

src/run_prim.rs

@@ -4,6 +4,7 @@
 
 use ecow::EcoVec;
 use regex::Regex;
+use smallvec::SmallVec;
 
 use core::str;
 use std::{
@@ -350,7 +351,7 @@ pub fn run_prim_func(prim: &Primitive, env: &mut Uiua) -> UiuaResult {
     Ok(())
 }
 /// Execute a primitive as a modifier
-pub fn run_prim_mod(prim: &Primitive, ops: Ops, env: &mut Uiua) -> UiuaResult {
+pub fn run_prim_mod(prim: &Primitive, mut ops: Ops, env: &mut Uiua) -> UiuaResult {
     match prim {
         // Looping
         Primitive::Reduce => reduce::reduce(ops, 0, env)?,
@@ -388,11 +389,17 @@ pub fn run_prim_mod(prim: &Primitive, ops: Ops, env: &mut Uiua) -> UiuaResult {
             env.exec(f)?;
         }
         Primitive::Bracket => {
-            let [f, g] = get_ops(ops, env)?;
-            let vals = env.pop_n(f.sig.args())?;
-            env.exec(g)?;
-            env.push_all(vals);
-            env.exec(f)?;
+            let mut args: SmallVec<[Vec<Value>; 3]> = SmallVec::new();
+            for sn in ops.iter().rev().skip(1).rev() {
+                args.push(env.pop_n(sn.sig.args())?);
+            }
+            if let Some(last) = ops.pop() {
+                env.exec(last)?;
+            }
+            for (sn, args) in ops.into_iter().zip(args).rev() {
+                env.push_all(args);
+                env.exec(sn)?;
+            }
         }
         Primitive::Both => {
             let [f] = get_ops(ops, env)?;
@@ -1305,11 +1312,15 @@ impl ImplPrimitive {
             &ImplPrimitive::SidedFill(side) => fill!(ops, side, env, with_fill, without_fill_but),
             ImplPrimitive::ReduceTable => table::reduce_table(ops, env)?,
             ImplPrimitive::UnBracket => {
-                let [f, g] = get_ops(ops, env)?;
-                env.exec(f.node)?;
-                let f_outputs = env.pop_n(f.sig.outputs())?;
-                env.exec(g.node)?;
-                env.push_all(f_outputs);
+                let mut outputs: SmallVec<[Vec<Value>; 3]> = SmallVec::new();
+                for sn in ops {
+                    let o = sn.sig.outputs();
+                    env.exec(sn)?;
+                    outputs.push(env.pop_n(o)?);
+                }
+                for outputs in outputs.into_iter().rev() {
+                    env.push_all(outputs);
+                }
             }
             ImplPrimitive::SplitByScalar => {
                 let [f] = get_ops(ops, env)?;