Short-circuit on errors in try ... catch ....

README.md

@@ -672,32 +672,6 @@ it requires completely separate logic from `foreach/2` and `reduce`
 in both the parser and the interpreter.
 
 
-## Error handling
-
-In jq, the `try f catch g` expression breaks out of the `f` stream as
-soon as an error occurs, ceding control to `g` after that. This is
-mentioned in its manual as a possible mechanism for breaking out of
-loops
-([here](https://jqlang.github.io/jq/manual/#breaking-out-of-control-structures)). jaq
-however doesn't interrupt the `f` stream, but instead sends _each_
-error value emitted to the `g` filter; the result is a stream of
-values emitted from `f` with values emitted from `g` interspersed
-where errors occurred.
-
-Consider the following example: this expression is `true` in jq,
-because the first `error(2)` interrupts the stream:
-
-```jq
-[try (1, error(2), 3, error(4)) catch .] == [1, 2]
-```
-
-In jaq however, this holds:
-
-```jq
-[try (1, error(2), 3, error(4)) catch .] == [1, 2, 3, 4]
-```
-
-
 ## Miscellaneous
 
 * Slurping: When files are slurped in (via the `-s` / `--slurp` option),

jaq-core/src/compile.rs

@@ -439,10 +439,17 @@ impl<'s, F> Compiler<&'s str, F> {
                 t
             }
             Num(n) => n.parse().map_or_else(|_| Term::Num(n.into()), Term::Int),
-            TryCatch(t, c) => Term::TryCatch(
-                self.iterm(*t),
-                self.iterm_tr(c.map_or_else(|| Call("!empty", Vec::new()), |c| *c)),
-            ),
+            // 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(t, c) => {
+                let (label, break_) = (Local::Label(""), Break(""));
+                let catch = match c {
+                    None => break_,
+                    Some(c) => BinOp(c, parse::BinaryOp::Comma, break_.into()),
+                };
+                let tc = self.with(label, |c| Term::TryCatch(c.iterm(*t), c.iterm(catch)));
+                Term::Label(self.lut.insert_term(tc))
+            }
             Fold(name, xs, x, args) => {
                 let arity = args.len();
                 let fold = match name {

jaq-core/tests/tests.rs

@@ -88,7 +88,7 @@ fn alt() {
 fn try_() {
     give(json!(0), ".?", json!(0));
     give(json!(0), r#"(-"a")?, 1"#, json!(1));
-    give(json!(0), r#"[(1, -"a", 2)?]"#, json!([1, 2]));
+    give(json!(0), r#"[(1, -"a", 2)?]"#, json!([1]));
 }
 
 #[test]
@@ -235,12 +235,10 @@ yields!(
     [1, 2]
 );
 
-// This behaviour diverges from jq. In jaq, a `try` will propagate all
-// errors in the stream to the `catch` filter.
 yields!(
-    try_catch_does_not_short_circuit,
+    try_catch_short_circuit,
     "[try (\"1\", \"2\", {}[0], \"4\") catch .]",
-    ["1", "2", "cannot index {} with 0", "4"]
+    ["1", "2", "cannot index {} with 0"]
 );
 yields!(
     try_catch_nested,
@@ -252,7 +250,7 @@ yields!(
     "[(try (1,2,3[0]) catch (3,4)) | . - 1]",
     [0, 1, 2, 3]
 );
-yields!(try_without_catch, "[try (1,2,3[0],4)]", [1, 2, 4]);
+yields!(try_without_catch, "[try (1,2,3[0],4)]", [1, 2]);
 yields!(
     try_catch_prefix_operation,
     r#"(try -[] catch .) | . > "" and . < []"#,