Implement try-catch without label $x | ....

Author: 01mf02

jaq-core/src/compile.rs

@@ -671,15 +671,9 @@ impl<'s, F> Compiler<&'s str, F> {
                 t
             }
             Num(n) => n.parse().map_or_else(|_| Term::Num(n.into()), Term::Int),
-            // map `try f catch g` to `label $x | try f catch (g, break $x)`
-            // and `try f` or `f?` to `label $x | try f catch (   break $x)`
             TryCatch(try_, catch) => {
-                let catch = match catch {
-                    None => Break(""),
-                    Some(c) => BinOp(c, parse::BinaryOp::Comma, Break("").into()),
-                };
-                let tc = self.with_label("", |c| Term::TryCatch(c.iterm(*try_), c.iterm(catch)));
-                Term::Label(self.lut.insert_term(tc))
+                let catch = catch.map_or_else(|| Call("!empty", Vec::new()), |t| *t);
+                Term::TryCatch(self.iterm(*try_), self.iterm(catch))
             }
             Fold(name, xs, pat, args) => {
                 use self::Fold::{Foreach, Reduce};

jaq-core/src/filter.rs

@@ -321,11 +321,18 @@ impl<F: FilterT<F>> FilterT<F> for Id {
             Ast::ObjSingle(k, v) => Box::new(
                 Self::cartesian(k, v, lut, cv).map(|(k, v)| Ok(Self::V::from_map([(k?, v?)])?)),
             ),
-            // TODO: write test for `try (break $x)`
             Ast::TryCatch(f, c) => {
-                Box::new(f.run(lut, (cv.0.clone(), cv.1)).flat_map(move |y| match y {
-                    Err(Exn(exn::Inner::Err(e))) => c.run(lut, (cv.0.clone(), e.into_val())),
-                    y => box_once(y),
+                let mut ys = f.run(lut, (cv.0.clone(), cv.1));
+                let mut end: Option<ValXs<_>> = None;
+                Box::new(core::iter::from_fn(move || match &mut end {
+                    Some(end) => end.next(),
+                    None => match ys.next()? {
+                        Err(Exn(exn::Inner::Err(e))) => {
+                            end = Some(c.run(lut, (cv.0.clone(), e.into_val())));
+                            end.as_mut().and_then(|end| end.next())
+                        }
+                        y => Some(y),
+                    },
                 }))
             }
             Ast::Neg(f) => Box::new(f.run(lut, cv).map(|v| Ok((-v?)?))),