Store TermId by reference in Exn.

Author: 01mf02

jaq-core/src/exn.rs

@@ -1,6 +1,6 @@
 //! Exceptions and errors.
 
-use crate::RcList;
+use crate::{compile::TermId, filter::Vars, RcList};
 use alloc::{boxed::Box, string::String, string::ToString, vec::Vec};
 use core::fmt::{self, Display};
 
@@ -11,16 +11,16 @@ use core::fmt::{self, Display};
 ///
 /// Use [`crate::val::unwrap_valr`] to convert a [`crate::val::ValX`] to an error.
 #[derive(Clone, Debug)]
-pub struct Exn<V>(pub(crate) Inner<V>);
+pub struct Exn<'a, V>(pub(crate) Inner<'a, V>);
 
 #[derive(Clone, Debug)]
-pub(crate) enum Inner<V> {
+pub(crate) enum Inner<'a, V> {
     Err(Box<Error<V>>),
     /// Tail-recursive call.
     ///
     /// This is used internally to execute tail-recursive filters.
     /// If this can be observed by users, then this is a bug.
-    TailCall(Box<(crate::compile::TermId, crate::filter::Vars<V>, CallInput<V>)>),
+    TailCall(Box<(&'a TermId, Vars<V>, CallInput<V>)>),
     Break(usize),
 }
 
@@ -46,7 +46,7 @@ impl<V> CallInput<V> {
     }
 }
 
-impl<V> Exn<V> {
+impl<V> Exn<'_, V> {
     /// If the exception is an error, yield it, else yield the exception.
     pub(crate) fn get_err(self) -> Result<Error<V>, Self> {
         match self.0 {
@@ -56,7 +56,7 @@ impl<V> Exn<V> {
     }
 }
 
-impl<V> From<Error<V>> for Exn<V> {
+impl<V> From<Error<V>> for Exn<'_, V> {
     fn from(e: Error<V>) -> Self {
         Exn(Inner::Err(Box::new(e)))
     }

jaq-core/src/filter.rs

@@ -229,9 +229,9 @@ fn bind_run<'a, D: DataT, T: Clone + 'a>(
     run: IdRunFn<'a, D, T>,
 ) -> ValXs<'a, T, D::V<'a>> {
     match pat {
-        Pattern::Var => run(*r, (cv.0.cons_var(y), cv.1)),
+        Pattern::Var => run(r, (cv.0.cons_var(y), cv.1)),
         Pattern::Idx(pats) => {
-            let r = move |ctx, vp| run(*r, (ctx, vp));
+            let r = move |ctx, vp| run(r, (ctx, vp));
             flat_map_then_with(bind_pats(pats, cv.0.clone(), (cv.0, y)), cv.1, r)
         }
     }
@@ -249,7 +249,7 @@ fn label_run<'a, D: DataT, T: 'a>(
     }))
 }
 
-fn try_catch_run<'a, T: 'a, V: 'a, I: Iterator<Item = ValX<T, V>> + 'a>(
+fn try_catch_run<'a, T: 'a, V: 'a, I: Iterator<Item = ValX<'a, T, V>> + 'a>(
     mut ys: ValXs<'a, T, V>,
     f: impl Fn(Error<V>) -> I + 'a,
 ) -> ValXs<'a, T, V> {
@@ -267,23 +267,23 @@ fn try_catch_run<'a, T: 'a, V: 'a, I: Iterator<Item = ValX<T, V>> + 'a>(
 }
 
 fn fold_run<'a, D: DataT, T: Clone + 'a>(
-    xs: impl Iterator<Item = ValX<Ctx<'a, D>, D::V<'a>>> + Clone + 'a,
+    xs: impl Iterator<Item = ValX<'a, Ctx<'a, D>, D::V<'a>>> + Clone + 'a,
     cv: Cv<'a, D, T>,
     init: &'a Id,
     update: &'a Id,
     fold_type: &'a Fold<Id>,
     run: IdRunFn<'a, D, T>,
 ) -> ValXs<'a, T, D::V<'a>> {
-    let init = run(*init, cv.clone());
-    let update = move |ctx, v| run(*update, (ctx, v));
+    let init = run(init, cv.clone());
+    let update = move |ctx, v| run(update, (ctx, v));
     let inner = |_, y: &T| Some(y.clone());
     let inner_proj = |ctx, y: &T| Some((ctx, y.clone()));
     flat_map_then_with(init, xs, move |i, xs| match fold_type {
         Fold::Reduce => Box::new(fold(xs, i, update, |_| (), |_, _| None, Some)),
         Fold::Foreach(None) => Box::new(fold(xs, i, update, |_| (), inner, |_| None)),
         Fold::Foreach(Some(proj)) => flat_map_then(
             fold(xs, i, update, |ctx| ctx.clone(), inner_proj, |_| None),
-            move |(ctx, y)| run(*proj, (ctx, y)),
+            move |(ctx, y)| run(proj, (ctx, y)),
         ),
     })
 }
@@ -302,7 +302,7 @@ where
 type Pairs<'a, T> = box_iter::BoxIter<'a, (T, T)>;
 
 /// Run `self` and `r` and return the cartesian product of their outputs.
-fn cartesian<'a, D: DataT>(l: &'a Id, r: &'a Id, cv: Cv<'a, D>) -> Pairs<'a, ValX<D::V<'a>>> {
+fn cartesian<'a, D: DataT>(l: &'a Id, r: &'a Id, cv: Cv<'a, D>) -> Pairs<'a, ValX<'a, D::V<'a>>> {
     flat_map_with(l.run(cv.clone()), cv, move |l, cv| {
         map_with(r.run(cv), l, |r, l| (l, r))
     })
@@ -312,7 +312,7 @@ fn fold_update<'a, D: DataT>(
     fold_type: &'a Fold<Id>,
     path: &'a Id,
     v: D::V<'a>,
-    mut xs: impl Iterator<Item = ValX<Ctx<'a, D>, D::V<'a>>> + Clone + 'a,
+    mut xs: impl Iterator<Item = ValX<'a, Ctx<'a, D>, D::V<'a>>> + Clone + 'a,
     f: BoxUpdate<'a, D::V<'a>>,
 ) -> ValXs<'a, D::V<'a>> {
     let ctx = match xs.next() {
@@ -351,10 +351,10 @@ fn def_run<'a, D: DataT, T: 'a>(
     from: fn(exn::CallInput<D::V<'a>>) -> T,
 ) -> ValXs<'a, T, D::V<'a>> {
     use core::ops::ControlFlow;
-    let outs = |cvs| flat_map_then(cvs, move |cv| run(*id, cv));
+    let outs = |cvs| flat_map_then(cvs, move |cv| run(id, cv));
     let catch = |all: bool| {
         move |r| match r {
-            Err(Exn(exn::Inner::TailCall(tc))) if all || tc.0 == *id => {
+            Err(Exn(exn::Inner::TailCall(tc))) if all || tc.0 == id => {
                 ControlFlow::Continue(run(tc.0, (with_vars(tc.1), from(tc.2))))
             }
             Ok(_) | Err(_) => ControlFlow::Break(r),
@@ -367,7 +367,7 @@ fn def_run<'a, D: DataT, T: 'a>(
         CallType::CatchAll => Box::new(crate::Stack::new([outs(cvs)].into(), catch(true))),
         CallType::Throw => Box::new(cvs.map(move |cv| {
             cv.and_then(|cv| {
-                let tc = (*id, cv.0.vars, into(cv.1));
+                let tc = (id, cv.0.vars, into(cv.1));
                 Err(Exn(exn::Inner::TailCall(Box::new(tc))))
             })
         })),
@@ -423,7 +423,7 @@ pub struct Native<D: DataT + ?Sized> {
     update: UpdatePtr<D>,
 }
 
-type IdRunFn<'a, D, T> = fn(Id, Cv<'a, D, T>) -> ValXs<'a, T, <D as DataT>::V<'a>>;
+type IdRunFn<'a, D, T> = fn(&Id, Cv<'a, D, T>) -> ValXs<'a, T, <D as DataT>::V<'a>>;
 
 /// Run function pointer (see [`Id::run`]).
 pub type RunPtr<D> = for<'a> fn(Cv<'a, D>) -> ValXs<'a, <D as DataT>::V<'a>>;
@@ -461,7 +461,7 @@ impl<D: DataT> Native<D> {
 
 impl Id {
     /// `f.run((c, v))` returns the output of `v | f` in the context `c`.
-    pub fn run<'a, D: DataT>(self, cv: Cv<'a, D>) -> ValXs<'a, D::V<'a>> {
+    pub fn run<'a, D: DataT>(&self, cv: Cv<'a, D>) -> ValXs<'a, D::V<'a>> {
         use core::iter::once;
         match &cv.0.lut().terms[self.0] {
             Ast::Id => box_once(Ok(cv.1)),
@@ -575,7 +575,7 @@ impl Id {
     ///
     /// In particular, `v | path(f)` in context `c` yields the same paths as
     /// `f.paths((c, (v, Default::default())))`.
-    pub fn paths<'a, D: DataT>(self, cv: Cvp<'a, D>) -> ValPathXs<'a, D::V<'a>> {
+    pub fn paths<'a, D: DataT>(&self, cv: Cvp<'a, D>) -> ValPathXs<'a, D::V<'a>> {
         let err = |v| box_once(Err(Exn::from(Error::path_expr(v))));
         let proj_cv = |cv: &Cvp<'a, D>| (cv.0.clone(), cv.1 .0.clone());
         let proj_val = |(val, _path): &(D::V<'a>, _)| val.clone();
@@ -658,7 +658,7 @@ impl Id {
 
     /// `p.update((c, v), f)` returns the output of `v | p |= f` in the context `c`.
     pub fn update<'a, D: DataT>(
-        self,
+        &self,
         cv: Cv<'a, D>,
         f: BoxUpdate<'a, D::V<'a>>,
     ) -> ValXs<'a, D::V<'a>> {

jaq-core/src/path.rs

@@ -83,7 +83,7 @@ impl<'a, V: ValT + 'a> Path<V> {
         run(self.0.into_iter(), vp, |part, vp| part.paths(vp))
     }
 
-    pub(crate) fn update<F>(mut self, v: V, f: F) -> ValX<V>
+    pub(crate) fn update<F>(mut self, v: V, f: F) -> ValX<'a, V>
     where
         F: Fn(V) -> ValXs<'a, V>,
     {
@@ -110,7 +110,7 @@ fn run<'a, V: 'a, T: 'a>(
     }
 }
 
-fn update<'a, V: ValT, P, F>(mut iter: P, last: (Part<V>, Opt), v: V, f: &F) -> ValX<V>
+fn update<'a, V: ValT + 'a, P, F>(mut iter: P, last: (Part<V>, Opt), v: V, f: &F) -> ValX<'a, V>
 where
     P: Iterator<Item = (Part<V>, Opt)> + Clone,
     F: Fn(V) -> ValXs<'a, V>,
@@ -146,10 +146,10 @@ impl<'a, V: ValT + 'a> Part<V> {
         }
     }
 
-    fn update<F, I>(&self, v: V, opt: Opt, f: F) -> ValX<V>
+    fn update<F, I>(&self, v: V, opt: Opt, f: F) -> ValX<'a, V>
     where
         F: Fn(V) -> I,
-        I: Iterator<Item = ValX<V>>,
+        I: Iterator<Item = ValX<'a, V>>,
     {
         match self {
             Self::Index(idx) => v.map_index(idx, opt, f),

jaq-core/src/val.rs

@@ -19,9 +19,9 @@ pub type ValRs<'a, T, V = T> = BoxIter<'a, ValR<T, V>>;
 /// Value or eXception.
 ///
 /// Use [`unwrap_valr`] to convert to [`ValR`].
-pub type ValX<T, V = T> = Result<T, crate::Exn<V>>;
+pub type ValX<'a, T, V = T> = Result<T, crate::Exn<'a, V>>;
 /// Stream of values and eXceptions.
-pub type ValXs<'a, T, V = T> = BoxIter<'a, ValX<T, V>>;
+pub type ValXs<'a, T, V = T> = BoxIter<'a, ValX<'a, T, V>>;
 
 /// Convert a value exception [`ValX`] into a value result [`ValR`].
 ///
@@ -101,35 +101,35 @@ pub trait ValT:
     ///
     /// - If `opt` is [`Opt::Essential`], return an error.
     /// - If `opt` is [`Opt::Optional`] , return the input value.
-    fn map_values<I: Iterator<Item = ValX<Self>>>(
+    fn map_values<'a, I: Iterator<Item = ValX<'a, Self>>>(
         self,
         opt: Opt,
         f: impl Fn(Self) -> I,
-    ) -> ValX<Self>;
+    ) -> ValX<'a, Self>;
 
     /// Map a function over the child of the value at the given index.
     ///
     /// This is used by `.[k] |= f`.
     ///
     /// See [`Self::map_values`] for the behaviour of `opt`.
-    fn map_index<I: Iterator<Item = ValX<Self>>>(
+    fn map_index<'a, I: Iterator<Item = ValX<'a, Self>>>(
         self,
         index: &Self,
         opt: Opt,
         f: impl Fn(Self) -> I,
-    ) -> ValX<Self>;
+    ) -> ValX<'a, Self>;
 
     /// Map a function over the slice of the value with the given range.
     ///
     /// This is used by `.[s:e] |= f`, `.[s:] |= f`, and `.[:e] |= f`.
     ///
     /// See [`Self::map_values`] for the behaviour of `opt`.
-    fn map_range<I: Iterator<Item = ValX<Self>>>(
+    fn map_range<'a, I: Iterator<Item = ValX<'a, Self>>>(
         self,
         range: Range<&Self>,
         opt: Opt,
         f: impl Fn(Self) -> I,
-    ) -> ValX<Self>;
+    ) -> ValX<'a, Self>;
 
     /// Return a boolean representation of the value.
     ///

jaq-fmts/src/read/funs.rs

@@ -38,7 +38,7 @@ pub fn funs<D: for<'a> DataT<V<'a> = Val>>() -> Box<[Filter<RunPtr<D>>]> {
 }
 
 /// Box Map, Map Error.
-fn bmme<'a>(iter: BoxIter<'a, ValR>) -> BoxIter<'a, ValX> {
+fn bmme<'a>(iter: BoxIter<'a, ValR>) -> BoxIter<'a, ValX<'a>> {
     Box::new(iter.map(|r| r.map_err(Exn::from)))
 }
 

jaq-json/src/funs.rs

@@ -114,7 +114,7 @@ impl Val {
 }
 
 /// Box Map, Map Error.
-fn bmme<'a>(iter: BoxIter<'a, ValR>) -> BoxIter<'a, ValX> {
+fn bmme<'a>(iter: BoxIter<'a, ValR>) -> BoxIter<'a, ValX<'a>> {
     Box::new(iter.map(|r| r.map_err(Exn::from)))
 }
 

jaq-json/src/lib.rs

@@ -121,7 +121,7 @@ pub type Error = jaq_core::Error<Val>;
 /// A value or an eRror.
 pub type ValR = jaq_core::ValR<Val>;
 /// A value or an eXception.
-pub type ValX = jaq_core::ValX<Val>;
+pub type ValX<'a> = jaq_core::ValX<'a, Val>;
 
 // This is part of the Rust standard library since 1.76:
 // <https://doc.rust-lang.org/std/rc/struct.Rc.html#method.unwrap_or_clone>.
@@ -176,7 +176,11 @@ impl jaq_core::ValT for Val {
         }
     }
 
-    fn map_values<I: Iterator<Item = ValX>>(self, opt: path::Opt, f: impl Fn(Self) -> I) -> ValX {
+    fn map_values<'a, I: Iterator<Item = ValX<'a>>>(
+        self,
+        opt: path::Opt,
+        f: impl Fn(Self) -> I,
+    ) -> ValX<'a> {
         match self {
             Self::Arr(a) => {
                 let iter = rc_unwrap_or_clone(a).into_iter().flat_map(f);
@@ -191,12 +195,12 @@ impl jaq_core::ValT for Val {
         }
     }
 
-    fn map_index<I: Iterator<Item = ValX>>(
+    fn map_index<'a, I: Iterator<Item = ValX<'a>>>(
         mut self,
         index: &Self,
         opt: path::Opt,
         f: impl Fn(Self) -> I,
-    ) -> ValX {
+    ) -> ValX<'a> {
         if let (Val::BStr(_) | Val::TStr(_) | Val::Arr(_), Val::Obj(o)) = (&self, index) {
             let range = o.get(&Val::utf8_str("start"))..o.get(&Val::utf8_str("end"));
             return self.map_range(range, opt, f);
@@ -243,12 +247,12 @@ impl jaq_core::ValT for Val {
         }
     }
 
-    fn map_range<I: Iterator<Item = ValX>>(
+    fn map_range<'a, I: Iterator<Item = ValX<'a>>>(
         mut self,
         range: val::Range<&Self>,
         opt: path::Opt,
         f: impl Fn(Self) -> I,
-    ) -> ValX {
+    ) -> ValX<'a> {
         let fs = |b: Bytes, range, skip_take: SkipTakeFn, from: ValBytesFn, into: BytesValFn| {
             let (skip, take) = match Self::range_int(range) {
                 Ok(range) => skip_take(range, &b),

jaq-std/src/input.rs

@@ -46,7 +46,7 @@ where
     ])
 }
 
-fn inputs<'a, D: DataT>(cv: Cv<'a, D>) -> impl Iterator<Item = ValX<D::V<'a>>> + 'a
+fn inputs<'a, D: DataT>(cv: Cv<'a, D>) -> impl Iterator<Item = ValX<'a, D::V<'a>>> + 'a
 where
     D::Data<'a>: HasInputs<'a, D::V<'a>>,
 {

jaq-std/src/lib.rs

@@ -173,9 +173,9 @@ trait ValTx: ValT + Sized {
     }
 
     /// Apply a function to an array.
-    fn try_mutate_arr<F>(self, f: F) -> ValX<Self>
+    fn try_mutate_arr<'a, F>(self, f: F) -> ValX<'a, Self>
     where
-        F: FnOnce(&mut Vec<Self>) -> Result<(), Exn<Self>>,
+        F: FnOnce(&mut Vec<Self>) -> Result<(), Exn<'a, Self>>,
     {
         let mut a = self.into_vec()?;
         f(&mut a)?;
@@ -237,7 +237,7 @@ trait ValTx: ValT + Sized {
 impl<T: ValT> ValTx for T {}
 
 /// Sort array by the given function.
-fn sort_by<'a, V: ValT>(xs: &mut [V], f: impl Fn(V) -> ValXs<'a, V>) -> Result<(), Exn<V>> {
+fn sort_by<'a, V: ValT>(xs: &mut [V], f: impl Fn(V) -> ValXs<'a, V>) -> Result<(), Exn<'a, V>> {
     // Some(e) iff an error has previously occurred
     let mut err = None;
     xs.sort_by_cached_key(|x| {
@@ -256,7 +256,7 @@ fn sort_by<'a, V: ValT>(xs: &mut [V], f: impl Fn(V) -> ValXs<'a, V>) -> Result<(
 }
 
 /// Group an array by the given function.
-fn group_by<'a, V: ValT>(xs: Vec<V>, f: impl Fn(V) -> ValXs<'a, V>) -> ValX<V> {
+fn group_by<'a, V: ValT>(xs: Vec<V>, f: impl Fn(V) -> ValXs<'a, V>) -> ValX<'a, V> {
     let mut yx: Vec<(Vec<V>, V)> = xs
         .into_iter()
         .map(|x| Ok((f(x.clone()).collect::<Result<_, _>>()?, x)))
@@ -284,7 +284,7 @@ fn group_by<'a, V: ValT>(xs: Vec<V>, f: impl Fn(V) -> ValXs<'a, V>) -> ValX<V> {
 }
 
 /// Get the minimum or maximum element from an array according to the given function.
-fn cmp_by<'a, V: Clone, F, R>(xs: Vec<V>, f: F, replace: R) -> Result<Option<V>, Exn<V>>
+fn cmp_by<'a, V: Clone, F, R>(xs: Vec<V>, f: F, replace: R) -> Result<Option<V>, Exn<'a, V>>
 where
     F: Fn(V) -> ValXs<'a, V>,
     R: Fn(&[V], &[V]) -> bool,