exec working up to halt

clean shutdown doesn't for some reason

orchid-std/src/macros/let_line.rs

@@ -3,13 +3,13 @@ use std::pin::pin;
 use futures::{FutureExt, StreamExt, stream};
 use hashbrown::HashMap;
 use itertools::Itertools;
-use orchid_api::Paren;
 use orchid_base::error::{OrcRes, Reporter};
 use orchid_base::name::Sym;
 use orchid_base::parse::{
 	Comment, ParseCtx, Parsed, Snippet, expect_tok, token_errv, try_pop_no_fluff,
 };
 use orchid_base::sym;
+use orchid_base::tree::Paren;
 use orchid_extension::gen_expr::{atom, call, sym_ref};
 use orchid_extension::parser::{ConstCtx, PSnippet, PTok, PTokTree, ParsCtx, ParsedLine, Parser};
 

orchid-std/src/macros/macro_lib.rs

@@ -32,7 +32,7 @@ pub fn gen_macro_lib() -> Vec<GenMember> {
 		),
 		fun(true, "resolve", |tpl: TypAtom<MacTree>| async move {
 			call([
-				sym_ref(sym!(macro::resolve_recur; tpl.untyped.ctx().i()).await),
+				sym_ref(sym!(macros::resolve_recur; tpl.untyped.ctx().i()).await),
 				atom(RecurState::Bottom),
 				tpl.untyped.ex().to_expr().await,
 			])
@@ -43,7 +43,7 @@ pub fn gen_macro_lib() -> Vec<GenMember> {
 			if let Some(e) = Reporter::new().errv() { Err(e) } else { Ok(res) }
 		}),
 		fun(true, "resolve_recur", |state: TypAtom<RecurState>, tpl: TypAtom<MacTree>| async move {
-			exec(async move |mut h| {
+			exec("macros::resolve_recur", async move |mut h| {
 				let ctx = tpl.ctx().clone();
 				let root = refl(&ctx);
 				let tpl = own(tpl.clone()).await;

orchid-std/src/macros/macro_line.rs

@@ -7,7 +7,6 @@ use futures::{StreamExt, stream};
 use hashbrown::{HashMap, HashSet};
 use itertools::Itertools;
 use never::Never;
-use orchid_api::Paren;
 use orchid_base::error::{OrcRes, Reporter, mk_errv};
 use orchid_base::interner::Tok;
 use orchid_base::location::Pos;
@@ -16,7 +15,7 @@ use orchid_base::parse::{
 	Comment, ParseCtx, Parsed, Snippet, expect_end, expect_tok, line_items, token_errv,
 	try_pop_no_fluff,
 };
-use orchid_base::tree::Token;
+use orchid_base::tree::{Paren, Token};
 use orchid_base::{clone, sym};
 use orchid_extension::atom::{Atomic, TypAtom};
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant};
@@ -142,7 +141,7 @@ impl Parser for MacroLine {
 					return Err(e);
 				}
 				Ok(call([
-					sym_ref(sym!(macro::resolve_recur; ctx.i()).await),
+					sym_ref(sym!(macros::resolve_recur; ctx.i()).await),
 					atom(RecurState::base(path)),
 					macro_input.to_expr().await,
 				]))

orchid-std/src/macros/mactree.rs

@@ -6,14 +6,13 @@ use futures::FutureExt;
 use futures::future::join_all;
 use hashbrown::HashSet;
 use itertools::Itertools;
-use orchid_api::Paren;
 use orchid_base::error::{OrcErrv, Reporter, mk_errv};
 use orchid_base::format::{FmtCtx, FmtUnit, Format, Variants, fmt};
 use orchid_base::interner::Tok;
 use orchid_base::location::Pos;
 use orchid_base::name::Sym;
 use orchid_base::tl_cache;
-use orchid_base::tree::indent;
+use orchid_base::tree::{Paren, indent};
 use orchid_extension::atom::Atomic;
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant};
 use orchid_extension::conv::ToExpr;

orchid-std/src/macros/resolve.rs

@@ -39,26 +39,29 @@ pub async fn resolve_seq(ctx: &mut ResolveCtx<'_>, val: &[MacTree]) -> Option<Ve
 	let mut any_changed = false;
 	let mut i = 0;
 	let mut val = val.to_vec();
-	while i < val.len() {
-		let MacTok::Name(key) = val[i].tok() else { continue };
-		let Some(options) = ctx.named.get(key) else { continue };
-		let matches = (options.iter())
-			.filter_map(|r| Some((r.1, r.2, r.0.apply(&val[i..], |_| false)?)))
-			.collect_vec();
-		match matches.len() {
-			0 => i += 1,
-			1 => {
-				any_changed = true;
-				let (mac, rule, (state, tail)) = matches.into_iter().exactly_one().unwrap();
-				let end = val.len() - tail.len();
-				let new_i = val.len() - tail.len();
-				let body_call = mk_body_call(mac, rule, &state, &ctx.ctx, ctx.recur.clone()).await;
-				std::mem::drop(state);
-				val.splice(i..end, [MacTok::Value(ctx.h.register(body_call).await).at(Pos::None)]);
-				i = new_i;
-			},
-			2.. => todo!("Named macros conflict!"),
+	'all_named: while i < val.len() {
+		'one_named: {
+			let MacTok::Name(key) = val[i].tok() else { break 'one_named };
+			let Some(options) = ctx.named.get(key) else { break 'one_named };
+			let matches = (options.iter())
+				.filter_map(|r| Some((r.1, r.2, r.0.apply(&val[i..], |_| false)?)))
+				.collect_vec();
+			match matches.len() {
+				0 => break 'one_named,
+				1 => {
+					any_changed = true;
+					let (mac, rule, (state, tail)) = matches.into_iter().exactly_one().unwrap();
+					let end = val.len() - tail.len();
+					let body_call = mk_body_call(mac, rule, &state, &ctx.ctx, ctx.recur.clone()).await;
+					std::mem::drop(state);
+					val.splice(i..end, [MacTok::Value(ctx.h.register(body_call).await).at(Pos::None)]);
+					i = end;
+				},
+				2.. => todo!("Named macros conflict!"),
+			}
+			continue 'all_named;
 		}
+		i += 1;
 	}
 	for (matcher, mac, rule) in &ctx.priod {
 		let Some(state) = matcher.apply(&val, |_| false) else { continue };