Generate objects lazily & remove itertools dependency

jaq-interpret/Cargo.toml

@@ -21,7 +21,6 @@ ahash = "0.7.6"
 dyn-clone = "1.0"
 hifijson = { version = "0.2.0", optional = true }
 indexmap = "2.0"
-itertools = "0.10.3"
 once_cell = "1.16.0"
 serde_json = { version = "1.0.81", optional = true }
 

jaq-interpret/src/filter.rs

@@ -1,4 +1,4 @@
-use crate::box_iter::{box_once, flat_map_with, map_with};
+use crate::box_iter::{box_once, flat_map_with, map_with, BoxIter};
 use crate::results::{fold, recurse, then, Results};
 use crate::val::{Val, ValR, ValRs};
 use crate::{rc_lazy_list, Bind, Ctx, Error};
@@ -120,6 +120,30 @@ where
     }
 }
 
+type ObjVec = Vec<(ValR, ValR)>;
+fn obj_cart<'a, I>(mut args: I, cv: Cv<'a>, prev: ObjVec) -> BoxIter<'a, ObjVec>
+where
+    I: Iterator<Item = (Ref<'a>, Ref<'a>)> + Clone + 'a,
+{
+    match args.next() {
+        Some((l, r)) => flat_map_with(
+            l.run(cv.clone()),
+            (args, cv, prev),
+            move |l, (args, cv, prev)| {
+                flat_map_with(
+                    r.run(cv.clone()),
+                    (l, args, cv, prev),
+                    |r, (l, args, cv, mut prev)| {
+                        prev.push((l, r));
+                        obj_cart(args, cv, prev)
+                    },
+                )
+            },
+        ),
+        None => box_once(prev),
+    }
+}
+
 fn reduce<'a, T: Clone + 'a, F>(xs: Results<'a, T, Error>, init: Val, f: F) -> ValRs
 where
     F: Fn(T, Val) -> ValRs<'a> + 'a,
@@ -188,7 +212,6 @@ impl<'a> FilterT<'a> for &'a Owned {
 impl<'a> FilterT<'a> for Ref<'a> {
     fn run(self, cv: Cv<'a>) -> ValRs<'a> {
         use core::iter::once;
-        use itertools::Itertools;
         // wrap a filter AST with the filter definitions
         let w = move |id: &Id| Ref(*id, self.1);
         match &self.1[self.0 .0] {
@@ -200,15 +223,12 @@ impl<'a> FilterT<'a> for Ref<'a> {
             Ast::Array(f) => box_once(w(f).run(cv).collect::<Result<_, _>>().map(Val::arr)),
             Ast::Object(o) if o.is_empty() => box_once(Ok(Val::Obj(Default::default()))),
             Ast::Object(o) => Box::new(
-                o.iter()
-                    .map(|(k, v)| Self::cartesian(w(k), w(v), cv.clone()).collect::<Vec<_>>())
-                    .multi_cartesian_product()
-                    .map(|kvs| {
-                        kvs.into_iter()
-                            .map(|(k, v)| Ok((k?.to_str()?, v?)))
-                            .collect::<Result<_, _>>()
-                            .map(Val::obj)
-                    }),
+                obj_cart(o.iter().map(move |(k, v)| (w(k), w(v))), cv, Vec::new()).map(|kvs| {
+                    kvs.into_iter()
+                        .map(|(k, v)| Ok((k?.to_str()?, v?)))
+                        .collect::<Result<_, _>>()
+                        .map(Val::obj)
+                }),
             ),
             Ast::Try(f, c) => Box::new(w(f).run((cv.0.clone(), cv.1)).flat_map(move |y| {
                 y.map_or_else(

jaq-interpret/src/lib.rs

@@ -191,6 +191,7 @@ impl ParseCtx {
 
         let inputs = RcIter::new(core::iter::empty());
         let out = f.run((Ctx::new([], &inputs), x));
-        itertools::assert_equal(out, ys);
+
+        assert!(out.eq(ys))
     }
 }

jaq-interpret/src/lir.rs

@@ -31,8 +31,6 @@ pub fn root_def(def: mir::Def) -> filter::Owned {
     filter::Owned::new(id, ctx.defs)
 }
 
-// TODO: remove itertools dependency
-
 impl Ctx {
     fn init_constants(&mut self) {
         for (f, id) in [(Filter::Id, IDENTITY), (Filter::ToString, TOSTRING)] {

jaq-interpret/src/path.rs

@@ -202,8 +202,8 @@ fn prod<'a, T: 'a + Clone>(
     l: impl Iterator<Item = T> + 'a,
     r: impl Iterator<Item = T> + 'a,
 ) -> impl Iterator<Item = (T, T)> + 'a {
-    use itertools::Itertools;
-    l.cartesian_product(r.collect::<Vec<T>>())
+    let r: Vec<_> = r.collect();
+    l.flat_map(move |l| r.clone().into_iter().map(move |r| (l.clone(), r)))
 }
 
 fn skip_take(from: usize, until: usize) -> (usize, usize) {