Use ControlFlow instead of Result.

Author: 01mf02

jaq-interpret/src/filter.rs

@@ -3,6 +3,7 @@ use crate::results::{fold, recurse, then, Fold, Results};
 use crate::val::{Val, ValR, ValRs};
 use crate::{rc_lazy_list, Bind, Ctx, Error};
 use alloc::{boxed::Box, string::String, vec::Vec};
+use core::ops::ControlFlow;
 use dyn_clone::DynClone;
 use jaq_syn::filter::FoldType;
 use jaq_syn::{MathOp, OrdOp};
@@ -342,9 +343,9 @@ impl<'a> FilterT<'a> for Ref<'a> {
                         Vec::from([Box::new(run_cvs(def, cvs)) as Results<_, _>]),
                         move |r| match r {
                             Err(Error::TailCall(TailCall(id, vars, v))) if id == call.id => {
-                                Err(def.run((Ctx { inputs, vars }, v)))
+                                ControlFlow::Continue(def.run((Ctx { inputs, vars }, v)))
                             }
-                            Ok(_) | Err(_) => Ok(r),
+                            Ok(_) | Err(_) => ControlFlow::Break(r),
                         },
                     )),
                     CallTyp::Throw => Box::new(cvs.map(move |cv| {

jaq-interpret/src/stack.rs

@@ -1,4 +1,5 @@
 use alloc::vec::Vec;
+use core::ops::ControlFlow;
 
 pub struct Stack<I, F>(Vec<I>, F);
 
@@ -8,9 +9,9 @@ impl<I, F> Stack<I, F> {
     }
 }
 
-/// If `F` returns `Ok(x)`, then `x` is returned
-/// If `F` returns `Err(iter)`, then the iterator is pushed onto the stack
-impl<I: Iterator, F: Fn(I::Item) -> Result<I::Item, I>> Iterator for Stack<I, F> {
+/// If `F` returns `Break(x)`, then `x` is returned
+/// If `F` returns `Continue(iter)`, then the iterator is pushed onto the stack
+impl<I: Iterator, F: Fn(I::Item) -> ControlFlow<I::Item, I>> Iterator for Stack<I, F> {
     type Item = I::Item;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -24,8 +25,8 @@ impl<I: Iterator, F: Fn(I::Item) -> Result<I::Item, I>> Iterator for Stack<I, F>
                     self.0.push(top);
                 }
                 match self.1(next) {
-                    Ok(next) => return Some(next),
-                    Err(iter) => self.0.push(iter),
+                    ControlFlow::Break(next) => return Some(next),
+                    ControlFlow::Continue(iter) => self.0.push(iter),
                 }
             }
         }