task_local context over context objects

- interner impls logically separate from API in orchid-base (default host interner still in base for testing)
- error reporting, logging, and a variety of other features passed down via context in extension, not yet in host to maintain library-ish profile, should consider options
- no global spawn mechanic, the host has a spawn function but extensions only get a stash for enqueuing async work in sync callbacks which is then explicitly, manually, and with strict order popped and awaited
- still deadlocks nondeterministically for some ungodly reason

orchid-std/src/macros/instantiate_tpl.rs

@@ -4,7 +4,6 @@ use never::Never;
 use orchid_base::format::fmt;
 use orchid_extension::atom::{Atomic, TAtom};
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant, own};
-use orchid_extension::context::i;
 use orchid_extension::conv::ToExpr;
 use orchid_extension::coroutine_exec::exec;
 use orchid_extension::expr::Expr;
@@ -38,7 +37,7 @@ impl OwnedAtom for InstantiateTplCall {
 	async fn call(mut self, arg: Expr) -> GExpr {
 		exec(async move |mut h| {
 			match h.exec::<TAtom<MacTree>>(arg.clone()).await {
-				Err(_) => panic!("Expected a macro param, found {}", fmt(&arg, &i()).await),
+				Err(_) => panic!("Expected a macro param, found {}", fmt(&arg).await),
 				Ok(t) => self.argv.push(own(&t).await),
 			};
 			if self.argv.len() < self.argc {

orchid-std/src/macros/let_line.rs

@@ -3,15 +3,13 @@ use std::pin::pin;
 use futures::{FutureExt, StreamExt, stream};
 use hashbrown::HashMap;
 use itertools::Itertools;
-use orchid_base::error::{OrcRes, Reporter};
+use orchid_base::error::{OrcRes, report, with_reporter};
+use orchid_base::interner::is;
 use orchid_base::name::Sym;
-use orchid_base::parse::{
-	Comment, ParseCtx, Parsed, Snippet, expect_tok, token_errv, try_pop_no_fluff,
-};
+use orchid_base::parse::{Comment, Parsed, Snippet, expect_tok, token_errv, try_pop_no_fluff};
 use orchid_base::sym;
 use orchid_base::tree::Paren;
 use orchid_extension::atom::TAtom;
-use orchid_extension::context::i;
 use orchid_extension::conv::TryFromExpr;
 use orchid_extension::gen_expr::{atom, call, sym_ref};
 use orchid_extension::parser::{ConstCtx, PSnippet, PTok, PTokTree, ParsCtx, ParsedLine, Parser};
@@ -24,40 +22,36 @@ pub struct LetLine;
 impl Parser for LetLine {
 	const LINE_HEAD: &'static str = "let";
 	async fn parse<'a>(
-		ctx: ParsCtx<'a>,
+		_: ParsCtx<'a>,
 		exported: bool,
 		comments: Vec<Comment>,
 		line: PSnippet<'a>,
 	) -> OrcRes<Vec<ParsedLine>> {
 		let sr = line.sr();
-		let Parsed { output: name_tok, tail } = try_pop_no_fluff(&ctx, line).await?;
+		let Parsed { output: name_tok, tail } = try_pop_no_fluff(line).await?;
 		let Some(name) = name_tok.as_name() else {
-			let err = token_errv(&ctx, name_tok, "Constant must have a name", |t| {
+			let err = token_errv(name_tok, "Constant must have a name", |t| {
 				format!("Expected a name but found {t}")
 			});
 			return Err(err.await);
 		};
-		let Parsed { tail, .. } = expect_tok(&ctx, tail, ctx.i().i("=").await).await?;
-		let aliased = parse_tokv(tail, &ctx).await;
+		let Parsed { tail, .. } = expect_tok(tail, is("=").await).await?;
+		let aliased = parse_tokv(tail).await;
 		Ok(vec![ParsedLine::cnst(&line.sr(), &comments, exported, name, async move |ctx| {
-			let rep = Reporter::new();
 			let macro_input =
-				MacTok::S(Paren::Round, dealias_mac_v(&aliased, &ctx, &rep).await).at(sr.pos());
-			if let Some(e) = rep.errv() {
-				return Err(e);
-			}
-			Ok(call(sym_ref(sym!(macros::resolve; i())), [atom(macro_input)]))
+				MacTok::S(Paren::Round, with_reporter(dealias_mac_v(&aliased, &ctx)).await?).at(sr.pos());
+			Ok(call(sym_ref(sym!(macros::resolve)), [atom(macro_input)]))
 		})])
 	}
 }
 
-pub async fn dealias_mac_v(aliased: &MacTreeSeq, ctx: &ConstCtx, rep: &Reporter) -> MacTreeSeq {
+pub async fn dealias_mac_v(aliased: &MacTreeSeq, ctx: &ConstCtx) -> MacTreeSeq {
 	let keys = aliased.glossary().iter().cloned().collect_vec();
 	let mut names: HashMap<_, _> = HashMap::new();
 	let mut stream = pin!(ctx.names(&keys).zip(stream::iter(&keys)));
 	while let Some((canonical, local)) = stream.next().await {
 		match canonical {
-			Err(e) => rep.report(e),
+			Err(e) => report(e),
 			Ok(name) => {
 				names.insert(local.clone(), name);
 			},
@@ -69,16 +63,16 @@ pub async fn dealias_mac_v(aliased: &MacTreeSeq, ctx: &ConstCtx, rep: &Reporter)
 	})
 }
 
-pub async fn parse_tokv(line: PSnippet<'_>, ctx: &impl ParseCtx) -> MacTreeSeq {
+pub async fn parse_tokv(line: PSnippet<'_>) -> MacTreeSeq {
 	if let Some((idx, arg)) = line.iter().enumerate().find_map(|(i, x)| Some((i, x.as_lambda()?))) {
 		let (head, lambda) = line.split_at(idx as u32);
 		let (_, body) = lambda.pop_front().unwrap();
-		let body = parse_tokv(body, ctx).boxed_local().await;
-		let mut all = parse_tokv_no_lambdas(&head, ctx).await;
-		match parse_tok(arg, ctx).await {
+		let body = parse_tokv(body).boxed_local().await;
+		let mut all = parse_tokv_no_lambdas(&head).await;
+		match parse_tok(arg).await {
 			Some(arg) => all.push(MacTok::Lambda(arg, body).at(lambda.sr().pos())),
-			None => ctx.rep().report(
-				token_errv(ctx, arg, "Lambda argument fluff", |arg| {
+			None => report(
+				token_errv(arg, "Lambda argument fluff", |arg| {
 					format!("Lambda arguments must be a valid token, found meaningless fragment {arg}")
 				})
 				.await,
@@ -86,29 +80,29 @@ pub async fn parse_tokv(line: PSnippet<'_>, ctx: &impl ParseCtx) -> MacTreeSeq {
 		};
 		MacTreeSeq::new(all)
 	} else {
-		MacTreeSeq::new(parse_tokv_no_lambdas(&line, ctx).await)
+		MacTreeSeq::new(parse_tokv_no_lambdas(&line).await)
 	}
 }
 
-async fn parse_tokv_no_lambdas(line: &[PTokTree], ctx: &impl ParseCtx) -> Vec<MacTree> {
-	stream::iter(line).filter_map(|tt| parse_tok(tt, ctx)).collect::<Vec<_>>().await
+async fn parse_tokv_no_lambdas(line: &[PTokTree]) -> Vec<MacTree> {
+	stream::iter(line).filter_map(parse_tok).collect::<Vec<_>>().await
 }
 
-pub async fn parse_tok(tree: &PTokTree, ctx: &impl ParseCtx) -> Option<MacTree> {
+pub async fn parse_tok(tree: &PTokTree) -> Option<MacTree> {
 	let tok = match &tree.tok {
 		PTok::Bottom(errv) => MacTok::Bottom(errv.clone()),
 		PTok::BR | PTok::Comment(_) => return None,
-		PTok::Name(n) => MacTok::Name(Sym::new([n.clone()], ctx.i()).await.unwrap()),
+		PTok::Name(n) => MacTok::Name(Sym::new([n.clone()]).await.unwrap()),
 		PTok::NS(..) => match tree.as_multiname() {
-			Ok(mn) => MacTok::Name(mn.to_sym(ctx.i()).await),
+			Ok(mn) => MacTok::Name(mn.to_sym().await),
 			Err(nested) => {
-				ctx.rep().report(
-					token_errv(ctx, tree, ":: can only be followed by a name in an expression", |tok| {
+				report(
+					token_errv(tree, ":: can only be followed by a name in an expression", |tok| {
 						format!("Expected name, found {tok}")
 					})
 					.await,
 				);
-				return parse_tok(nested, ctx).boxed_local().await;
+				return parse_tok(nested).boxed_local().await;
 			},
 		},
 		PTok::Handle(expr) => match TAtom::<PhAtom>::try_from_expr(expr.clone()).await {
@@ -117,8 +111,7 @@ pub async fn parse_tok(tree: &PTokTree, ctx: &impl ParseCtx) -> Option<MacTree>
 		},
 		PTok::NewExpr(never) => match *never {},
 		PTok::LambdaHead(_) => panic!("Lambda-head handled in the sequence parser"),
-		PTok::S(p, body) =>
-			MacTok::S(*p, parse_tokv(Snippet::new(tree, body), ctx).boxed_local().await),
+		PTok::S(p, body) => MacTok::S(*p, parse_tokv(Snippet::new(tree, body)).boxed_local().await),
 	};
 	Some(tok.at(tree.sr().pos()))
 }

orchid-std/src/macros/macro_lib.rs

@@ -1,7 +1,6 @@
 use orchid_base::sym;
 use orchid_extension::atom::TAtom;
 use orchid_extension::atom_owned::own;
-use orchid_extension::context::i;
 use orchid_extension::conv::ToExpr;
 use orchid_extension::coroutine_exec::exec;
 use orchid_extension::gen_expr::{call, sym_ref};
@@ -20,12 +19,12 @@ pub async fn gen_macro_lib() -> Vec<GenMember> {
 			build_macro(None, ["..", "_"]).finish(),
 			build_macro(Some(1), ["+"])
 				.rule(mactreev!("...$" lhs 0 macros::common::+ "...$" rhs 1), [async |[lhs, rhs]| {
-					call(sym_ref(sym!(std::number::add; i())), [resolve(lhs).await, resolve(rhs).await])
+					call(sym_ref(sym!(std::number::add)), [resolve(lhs).await, resolve(rhs).await])
 				}])
 				.finish(),
 			build_macro(Some(2), ["*"])
 				.rule(mactreev!("...$" lhs 0 macros::common::* "...$" rhs 1), [async |[lhs, rhs]| {
-					call(sym_ref(sym!(std::number::mul; i())), [resolve(lhs).await, resolve(rhs).await])
+					call(sym_ref(sym!(std::number::mul)), [resolve(lhs).await, resolve(rhs).await])
 				}])
 				.finish(),
 			build_macro(None, ["comma_list", ","])

orchid-std/src/macros/macro_line.rs

@@ -4,15 +4,14 @@ use async_fn_stream::stream;
 use async_once_cell::OnceCell;
 use futures::StreamExt;
 use itertools::Itertools;
-use orchid_base::error::{OrcRes, Reporter, mk_errv};
+use orchid_base::error::{OrcRes, mk_errv, report, with_reporter};
+use orchid_base::interner::is;
 use orchid_base::parse::{
-	Comment, ParseCtx, Parsed, Snippet, expect_end, expect_tok, line_items, token_errv,
-	try_pop_no_fluff,
+	Comment, Parsed, Snippet, expect_end, expect_tok, line_items, token_errv, try_pop_no_fluff,
 };
 use orchid_base::tree::{Paren, Token};
 use orchid_base::{clone, sym};
 use orchid_extension::atom::TAtom;
-use orchid_extension::context::i;
 use orchid_extension::conv::{ToExpr, TryFromExpr};
 use orchid_extension::gen_expr::{call, sym_ref};
 use orchid_extension::parser::{PSnippet, ParsCtx, ParsedLine, Parser};
@@ -35,22 +34,22 @@ impl Parser for MacroLine {
 	) -> OrcRes<Vec<ParsedLine>> {
 		if exported {
 			return Err(mk_errv(
-				ctx.i().i("macros are always exported").await,
+				is("macros are always exported").await,
 				"The export keyword is forbidden here to avoid confusion\n\
 					because macros are exported by default",
 				[line.sr()],
 			));
 		}
 		let module = ctx.module();
-		let Parsed { output: prio_or_body, tail } = try_pop_no_fluff(&ctx, line).await?;
+		let Parsed { output: prio_or_body, tail } = try_pop_no_fluff(line).await?;
 		let bad_first_item_err = || {
-			token_errv(&ctx, prio_or_body, "Expected priority or block", |s| {
+			token_errv(prio_or_body, "Expected priority or block", |s| {
 				format!("Expected a priority number or a () block, found {s}")
 			})
 		};
 		let (prio, body) = match &prio_or_body.tok {
 			Token::S(Paren::Round, body) => {
-				expect_end(&ctx, tail).await?;
+				expect_end(tail).await?;
 				(None, body)
 			},
 			Token::Handle(expr) => match TAtom::<Int>::try_from_expr(expr.clone()).await {
@@ -58,33 +57,32 @@ impl Parser for MacroLine {
 					return Err(e + bad_first_item_err().await);
 				},
 				Ok(prio) => {
-					let Parsed { output: body, tail } = try_pop_no_fluff(&ctx, tail).await?;
+					let Parsed { output: body, tail } = try_pop_no_fluff(tail).await?;
 					let Token::S(Paren::Round, block) = &body.tok else {
 						return Err(
-							token_errv(&ctx, prio_or_body, "Expected () block", |s| {
+							token_errv(prio_or_body, "Expected () block", |s| {
 								format!("Expected a () block, found {s}")
 							})
 							.await,
 						);
 					};
-					expect_end(&ctx, tail).await?;
+					expect_end(tail).await?;
 					(Some(prio), block)
 				},
 			},
 			_ => return Err(bad_first_item_err().await),
 		};
-		let lines = line_items(&ctx, Snippet::new(prio_or_body, body)).await;
+		let lines = line_items(Snippet::new(prio_or_body, body)).await;
 		let Some((kw_line, rule_lines)) = lines.split_first() else { return Ok(Vec::new()) };
 		let mut keywords = Vec::new();
-		let Parsed { tail: kw_tail, .. } =
-			expect_tok(&ctx, kw_line.tail, ctx.i().i("keywords").await).await?;
+		let Parsed { tail: kw_tail, .. } = expect_tok(kw_line.tail, is("keywords").await).await?;
 		for kw_tok in kw_tail.iter().filter(|kw| !kw.is_fluff()) {
 			match kw_tok.as_name() {
 				Some(kw) => {
 					keywords.push((kw, kw_tok.sr()));
 				},
-				None => ctx.rep().report(
-					token_errv(&ctx, kw_tok, "invalid macro keywords list", |tok| {
+				None => report(
+					token_errv(kw_tok, "invalid macro keywords list", |tok| {
 						format!("The keywords list must be a sequence of names; received {tok}")
 					})
 					.await,
@@ -93,7 +91,7 @@ impl Parser for MacroLine {
 		}
 		let Some((macro_name, _)) = keywords.first().cloned() else {
 			return Err(mk_errv(
-				ctx.i().i("macro with no keywords").await,
+				is("macro with no keywords").await,
 				"Macros must define at least one macro of their own.",
 				[kw_line.tail.sr()],
 			));
@@ -102,18 +100,18 @@ impl Parser for MacroLine {
 		let mut lines = Vec::new();
 		for (idx, line) in rule_lines.iter().enumerate().map(|(n, v)| (n as u32, v)) {
 			let sr = line.tail.sr();
-			let name = ctx.i().i(&format!("rule::{}::{}", macro_name, idx)).await;
-			let Parsed { tail, .. } = expect_tok(&ctx, line.tail, ctx.i().i("rule").await).await?;
-			let arrow_token = ctx.i().i("=>").await;
+			let name = is(&format!("rule::{}::{}", macro_name, idx)).await;
+			let Parsed { tail, .. } = expect_tok(line.tail, is("rule").await).await?;
+			let arrow_token = is("=>").await;
 			let Some((pattern, body)) = tail.split_once(|tok| tok.is_kw(arrow_token.clone())) else {
-				ctx.rep().report(mk_errv(
-					ctx.i().i("Missing => in rule").await,
+				report(mk_errv(
+					is("Missing => in rule").await,
 					"Rule lines are of the form `rule ...pattern => ...body`",
 					[line.tail.sr()],
 				));
 				continue;
 			};
-			let pattern = parse_tokv(pattern, &ctx).await;
+			let pattern = parse_tokv(pattern).await;
 			let mut placeholders = Vec::new();
 			pattern.map(&mut false, &mut |tok| {
 				if let MacTok::Ph(ph) = tok.tok() {
@@ -121,9 +119,9 @@ impl Parser for MacroLine {
 				}
 				None
 			});
-			let mut body_mactree = parse_tokv(body, &ctx).await;
+			let mut body_mactree = parse_tokv(body).await;
 			for (ph, ph_pos) in placeholders.iter().rev() {
-				let name = ctx.module().suffix([ph.name.clone()], ctx.i()).await;
+				let name = ctx.module().suffix([ph.name.clone()]).await;
 				body_mactree =
 					MacTreeSeq::new([
 						MacTok::Lambda(MacTok::Name(name).at(ph_pos.clone()), body_mactree).at(ph_pos.clone())
@@ -132,45 +130,40 @@ impl Parser for MacroLine {
 			let body_sr = body.sr();
 			rules.push((name.clone(), placeholders, pattern));
 			lines.push(ParsedLine::cnst(&sr, &line.output, true, name, async move |ctx| {
-				let rep = Reporter::new();
-				let body = dealias_mac_v(&body_mactree, &ctx, &rep).await;
-				let macro_input = MacTok::S(Paren::Round, body).at(body_sr.pos());
-				if let Some(e) = rep.errv() {
-					return Err(e);
-				}
-				Ok(call(sym_ref(sym!(macros::resolve; i())), [macro_input.to_gen().await]))
+				let macro_input =
+					MacTok::S(Paren::Round, with_reporter(dealias_mac_v(&body_mactree, &ctx)).await?)
+						.at(body_sr.pos());
+				Ok(call(sym_ref(sym!(macros::resolve)), [macro_input.to_gen().await]))
 			}))
 		}
 		let mac_cell = Rc::new(OnceCell::new());
 		let rules = Rc::new(rules);
 		for (kw, sr) in &*keywords {
 			clone!(mac_cell, rules, module, macro_name, prio);
-			let kw_key = i().i(&format!("__macro__{kw}")).await;
+			let kw_key = is(&format!("__macro__{kw}")).await;
 			lines.push(ParsedLine::cnst(&sr.clone(), &comments, true, kw_key, async move |cctx| {
 				let mac_future = async {
-					let rep = Reporter::new();
-					let rules = stream(async |mut h| {
-						for (body, ph_names, pattern_rel) in rules.iter() {
-							let pattern = dealias_mac_v(pattern_rel, &cctx, &rep).await;
-							let ph_names = ph_names.iter().map(|(ph, _)| ph.name.clone()).collect_vec();
-							match Matcher::new(pattern.clone()).await {
-								Ok(matcher) =>
-									h.emit(Rule { body: body.clone(), matcher, pattern, ph_names }).await,
-								Err(e) => rep.report(e),
+					let rules = with_reporter(
+						stream(async |mut h| {
+							for (body, ph_names, pattern_rel) in rules.iter() {
+								let pattern = dealias_mac_v(pattern_rel, &cctx).await;
+								let ph_names = ph_names.iter().map(|(ph, _)| ph.name.clone()).collect_vec();
+								match Matcher::new(pattern.clone()).await {
+									Ok(matcher) =>
+										h.emit(Rule { body: body.clone(), matcher, pattern, ph_names }).await,
+									Err(e) => report(e),
+								}
 							}
-						}
-					})
-					.collect::<Vec<_>>()
-					.await;
-					match rep.errv() {
-						Some(e) => Err(e),
-						None => Ok(Macro(Rc::new(MacroData {
-							canonical_name: module.suffix([macro_name], &i()).await,
-							module,
-							prio: prio.map(|i| i.0 as u64),
-							rules,
-						}))),
-					}
+						})
+						.collect::<Vec<_>>(),
+					)
+					.await?;
+					Ok(Macro(Rc::new(MacroData {
+						canonical_name: module.suffix([macro_name]).await,
+						module,
+						prio: prio.map(|i| i.0 as u64),
+						rules,
+					})))
 				};
 				mac_cell.get_or_init(mac_future).await.clone().to_gen().await
 			}))

orchid-std/src/macros/macro_system.rs

@@ -1,10 +1,8 @@
 use never::Never;
 use orchid_base::name::Sym;
-use orchid_base::reqnot::Receipt;
+use orchid_base::reqnot::{Receipt, ReqHandle};
 use orchid_base::sym;
 use orchid_extension::atom::{AtomDynfo, AtomicFeatures};
-use orchid_extension::context::i;
-use orchid_extension::entrypoint::ExtReq;
 use orchid_extension::lexer::LexerObj;
 use orchid_extension::other_system::SystemHandle;
 use orchid_extension::parser::ParserObj;
@@ -24,14 +22,14 @@ use crate::macros::std_macros::gen_std_macro_lib;
 use crate::macros::utils::MacroBodyArgCollector;
 use crate::{MacTree, StdSystem};
 
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct MacroSystem;
 impl SystemCtor for MacroSystem {
 	type Deps = StdSystem;
 	type Instance = Self;
 	const NAME: &'static str = "orchid::macros";
 	const VERSION: f64 = 0.00_01;
-	fn inst(_: SystemHandle<StdSystem>) -> Self::Instance { Self }
+	fn inst(&self, _: SystemHandle<StdSystem>) -> Self::Instance { Self }
 }
 impl SystemCard for MacroSystem {
 	type Ctor = Self;
@@ -48,19 +46,19 @@ impl SystemCard for MacroSystem {
 	}
 }
 impl System for MacroSystem {
-	async fn request(_: ExtReq<'_>, req: Never) -> Receipt<'_> { match req {} }
+	async fn request<'a>(_: Box<dyn ReqHandle<'a> + 'a>, req: Never) -> Receipt<'a> { match req {} }
 	async fn prelude() -> Vec<Sym> {
 		vec![
-			sym!(macros::common::+; i()),
-			sym!(macros::common::*; i()),
-			sym!(macros::common::,; i()),
-			sym!(macros::common::;; i()),
-			sym!(macros::common::..; i()),
-			sym!(macros::common::_; i()),
-			sym!(std::tuple::t; i()),
-			sym!(pattern::match; i()),
-			sym!(pattern::ref; i()),
-			sym!(pattern::=>; i()),
+			sym!(macros::common::+),
+			sym!(macros::common::*),
+			sym!(macros::common::,),
+			sym!(macros::common::;),
+			sym!(macros::common::..),
+			sym!(macros::common::_),
+			sym!(std::tuple::t),
+			sym!(pattern::match),
+			sym!(pattern::ref),
+			sym!(pattern::=>),
 		]
 	}
 	fn lexers() -> Vec<LexerObj> { vec![&MacTreeLexer, &PhLexer] }

orchid-std/src/macros/macro_value.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 use std::rc::Rc;
 
 use never::Never;
-use orchid_base::interner::Tok;
+use orchid_base::interner::IStr;
 use orchid_base::name::Sym;
 use orchid_extension::atom::Atomic;
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant};
@@ -25,8 +25,8 @@ pub struct Macro(pub Rc<MacroData>);
 pub struct Rule {
 	pub pattern: MacTreeSeq,
 	pub matcher: Matcher,
-	pub ph_names: Vec<Tok<String>>,
-	pub body: Tok<String>,
+	pub ph_names: Vec<IStr>,
+	pub body: IStr,
 }
 impl Atomic for Macro {
 	type Data = ();

orchid-std/src/macros/mactree.rs

@@ -8,7 +8,7 @@ use hashbrown::HashSet;
 use orchid_api_derive::Coding;
 use orchid_base::error::OrcErrv;
 use orchid_base::format::{FmtCtx, FmtUnit, Format, Variants};
-use orchid_base::interner::Tok;
+use orchid_base::interner::IStr;
 use orchid_base::location::Pos;
 use orchid_base::name::Sym;
 use orchid_base::tl_cache;
@@ -205,7 +205,7 @@ pub async fn mtreev_fmt<'b>(
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Ph {
-	pub name: Tok<String>,
+	pub name: IStr,
 	pub kind: PhKind,
 }
 impl Display for Ph {

orchid-std/src/macros/mactree_lexer.rs

@@ -3,7 +3,7 @@ use std::ops::RangeInclusive;
 use futures::FutureExt;
 use itertools::chain;
 use orchid_base::error::{OrcRes, mk_errv};
-use orchid_base::parse::ParseCtx;
+use orchid_base::interner::is;
 use orchid_base::tokens::PARENS;
 use orchid_base::tree::Paren;
 use orchid_extension::lexer::{LexContext, Lexer, err_not_applicable};
@@ -14,7 +14,7 @@ use crate::macros::instantiate_tpl::InstantiateTplCall;
 use crate::macros::let_line::parse_tok;
 use crate::macros::mactree::{MacTok, MacTree, MacTreeSeq};
 
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct MacTreeLexer;
 impl Lexer for MacTreeLexer {
 	const CHAR_FILTER: &'static [RangeInclusive<char>] = &['\''..='\''];
@@ -54,11 +54,9 @@ impl Lexer for MacTreeLexer {
 						let tok = MacTok::S(*paren, MacTreeSeq::new(items));
 						break Ok((tail3, tok.at(ctx.pos_tt(tail, tail3).pos())));
 					} else if tail2.is_empty() {
-						return Err(mk_errv(
-							ctx.i().i("Unclosed block").await,
-							format!("Expected closing {rp}"),
-							[ctx.pos_lt(1, tail)],
-						));
+						return Err(mk_errv(is("Unclosed block").await, format!("Expected closing {rp}"), [
+							ctx.pos_lt(1, tail),
+						]));
 					}
 					let (new_tail, new_item) = mac_tree(tail2, args, ctx).boxed_local().await?;
 					body_tail = new_tail;
@@ -87,7 +85,7 @@ impl Lexer for MacTreeLexer {
 				Ok((tail3, MacTok::Lambda(param, MacTreeSeq::new(body)).at(ctx.pos_tt(tail, tail3).pos())))
 			} else {
 				let (tail2, sub) = ctx.recurse(tail).await?;
-				let parsed = parse_tok(&sub, ctx).await.expect("Unexpected invalid token");
+				let parsed = parse_tok(&sub).await.expect("Unexpected invalid token");
 				Ok((tail2, parsed))
 			}
 		}

orchid-std/src/macros/match_macros.rs

@@ -8,11 +8,11 @@ use orchid_api::ExprTicket;
 use orchid_api_derive::Coding;
 use orchid_base::error::{OrcRes, mk_errv};
 use orchid_base::format::fmt;
+use orchid_base::interner::is;
 use orchid_base::name::Sym;
 use orchid_base::sym;
 use orchid_extension::atom::{Atomic, TAtom};
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant, own};
-use orchid_extension::context::i;
 use orchid_extension::conv::ToExpr;
 use orchid_extension::coroutine_exec::{ExecHandle, exec};
 use orchid_extension::expr::{Expr, ExprHandle};
@@ -43,7 +43,7 @@ impl MatcherData {
 	pub fn keys(&self) -> impl Stream<Item = Sym> {
 		stream(async |mut h| {
 			for tk in &self.keys {
-				h.emit(Sym::from_api(*tk, &i()).await).await
+				h.emit(Sym::from_api(*tk).await).await
 			}
 		})
 	}
@@ -85,7 +85,7 @@ pub async fn gen_match_macro_lib() -> Vec<GenMember> {
 			},
 		),
 		fun(true, "matcher", async |names: HomoTpl<TAtom<SymAtom>>, matcher: Expr| MatcherAtom {
-			keys: join_all(names.0.iter().map(async |atm| Sym::from_api(atm.0, &i()).await)).await,
+			keys: join_all(names.0.iter().map(async |atm| Sym::from_api(atm.0).await)).await,
 			matcher,
 		}),
 		build_macro(None, ["match", "match_rule", "_row", "=>"])
@@ -93,7 +93,7 @@ pub async fn gen_match_macro_lib() -> Vec<GenMember> {
 				async |[value, rules]| {
 					exec(async move |mut h| {
 						let rule_lines = h
-							.exec::<TAtom<Tuple>>(call(sym_ref(sym!(macros::resolve; i())), [
+							.exec::<TAtom<Tuple>>(call(sym_ref(sym!(macros::resolve)), [
 								mactree!(macros::common::semi_list "push" rules.clone();).to_gen().await,
 							]))
 							.await?;
@@ -105,20 +105,20 @@ pub async fn gen_match_macro_lib() -> Vec<GenMember> {
 								))
 								.await?;
 							let Tpl((matcher, body)) = h
-								.exec(call(sym_ref(sym!(macros::resolve; i())), [
+								.exec(call(sym_ref(sym!(macros::resolve)), [
 									mactree!(pattern::_row "push" own(&line_mac).await ;).to_gen().await,
 								]))
 								.await?;
 							rule_atoms.push((matcher, body));
 						}
 						let base_case = lambda(0, [bot(mk_errv(
-							i().i("No branches match").await,
+							is("No branches match").await,
 							"None of the patterns matches this value",
 							[rules.pos()],
 						))]);
 						let match_expr = stream::iter(rule_atoms.into_iter().rev())
 							.fold(base_case, async |tail, (mat, body)| {
-								lambda(0, [call(sym_ref(sym!(pattern::match_one; i())), [
+								lambda(0, [call(sym_ref(sym!(pattern::match_one)), [
 									mat.to_gen().await,
 									arg(0),
 									body.to_gen().await,
@@ -144,14 +144,14 @@ pub async fn gen_match_macro_lib() -> Vec<GenMember> {
 				async |[pattern, mut value]| {
 					exec(async move |mut h| -> OrcRes<Tpl<(TAtom<MatcherAtom>, GExpr)>> {
 						let Ok(pat) = h
-							.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve; i())), [
+							.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve)), [
 								mactree!(pattern::match_rule "push" pattern.clone();).to_gen().await,
 							]))
 							.await
 						else {
 							return Err(mk_errv(
-								i().i("Invalid pattern").await,
-								format!("Could not parse {} as a match pattern", fmt(&pattern, &i()).await),
+								is("Invalid pattern").await,
+								format!("Could not parse {} as a match pattern", fmt(&pattern).await),
 								[pattern.pos()],
 							));
 						};
@@ -169,18 +169,18 @@ pub async fn gen_match_macro_lib() -> Vec<GenMember> {
 			.rule(mactreev!(pattern::match_rule(pattern::ref "$" name)), [async |[name]| {
 				let MacTok::Name(name) = name.tok() else {
 					return Err(mk_errv(
-						i().i("pattern 'ref' requires a name to bind to").await,
+						is("pattern 'ref' requires a name to bind to").await,
 						format!(
 							"'ref' was interpreted as a binding matcher, \
 							but it was followed by {} instead of a name",
-							fmt(&name, &i()).await
+							fmt(&name).await
 						),
 						[name.pos()],
 					));
 				};
 				Ok(MatcherAtom {
 					keys: vec![name.clone()],
-					matcher: sym_ref(sym!(pattern::ref_body; i())).to_expr().await,
+					matcher: sym_ref(sym!(pattern::ref_body)).to_expr().await,
 				})
 			}])
 			.finish(),

orchid-std/src/macros/ph_lexer.rs

@@ -1,10 +1,10 @@
 use orchid_api_derive::Coding;
 use orchid_base::error::{OrcRes, mk_errv};
 use orchid_base::format::FmtUnit;
+use orchid_base::interner::{es, is};
 use orchid_base::parse::{name_char, name_start};
 use orchid_extension::atom::Atomic;
 use orchid_extension::atom_thin::{ThinAtom, ThinVariant};
-use orchid_extension::context::i;
 use orchid_extension::lexer::{LexContext, Lexer, err_not_applicable};
 use orchid_extension::tree::{GenTokTree, x_tok};
 
@@ -13,7 +13,7 @@ use crate::macros::mactree::{Ph, PhKind};
 #[derive(Clone, Coding)]
 pub struct PhAtom(orchid_api::TStr, PhKind);
 impl PhAtom {
-	pub async fn to_full(&self) -> Ph { Ph { kind: self.1, name: i().ex(self.0).await } }
+	pub async fn to_full(&self) -> Ph { Ph { kind: self.1, name: es(self.0).await } }
 }
 impl Atomic for PhAtom {
 	type Data = Self;
@@ -21,11 +21,11 @@ impl Atomic for PhAtom {
 }
 impl ThinAtom for PhAtom {
 	async fn print(&self) -> FmtUnit {
-		Ph { name: i().ex(self.0).await, kind: self.1 }.to_string().into()
+		Ph { name: es(self.0).await, kind: self.1 }.to_string().into()
 	}
 }
 
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct PhLexer;
 impl Lexer for PhLexer {
 	const CHAR_FILTER: &'static [std::ops::RangeInclusive<char>] = &['$'..='$', '.'..='.'];
@@ -52,7 +52,7 @@ impl Lexer for PhLexer {
 							(prio_num, tail)
 						} else {
 							return Err(mk_errv(
-								i().i("Invalid priority, must be 0-255").await,
+								is("Invalid priority, must be 0-255").await,
 								format!("{prio} is not a valid placeholder priority"),
 								[ctx.pos_lt(prio.len(), tail)],
 							));
@@ -71,7 +71,7 @@ impl Lexer for PhLexer {
 				return Err(err_not_applicable().await);
 			}
 		};
-		let ph_atom = PhAtom(i().i::<String>(name).await.to_api(), phkind);
+		let ph_atom = PhAtom(is(name).await.to_api(), phkind);
 		Ok((tail, x_tok(ph_atom).await.at(ctx.pos_tt(line, tail))))
 	}
 }

orchid-std/src/macros/resolve.rs

@@ -6,12 +6,13 @@ use hashbrown::{HashMap, HashSet};
 use itertools::Itertools;
 use orchid_base::error::mk_errv;
 use orchid_base::format::fmt;
+use orchid_base::interner::is;
 use orchid_base::location::Pos;
+use orchid_base::logging::logger;
 use orchid_base::name::{NameLike, Sym, VPath};
 use orchid_base::tree::Paren;
 use orchid_extension::atom::TAtom;
 use orchid_extension::atom_owned::own;
-use orchid_extension::context::{ctx, i};
 use orchid_extension::conv::ToExpr;
 use orchid_extension::coroutine_exec::{ExecHandle, exec};
 use orchid_extension::gen_expr::{GExpr, arg, bot, call, lambda, sym_ref};
@@ -26,17 +27,16 @@ use crate::{MacTok, MacTree};
 
 pub async fn resolve(val: MacTree) -> GExpr {
 	exec(async move |mut h| {
-		let ctx = ctx();
 		// if ctx.logger().is_active() {
-		writeln!(ctx.logger(), "Macro-resolving {}", fmt(&val, &i()).await);
+		writeln!(logger(), "Macro-resolving {}", fmt(&val).await);
 		// }
 		let root = refl();
 		let mut macros = HashMap::new();
 		for n in val.glossary() {
 			let (foot, body) = n.split_last_seg();
 			let new_name = VPath::new(body.iter().cloned())
-				.name_with_suffix(i().i(&format!("__macro__{foot}")).await)
-				.to_sym(&i())
+				.name_with_suffix(is(&format!("__macro__{foot}")).await)
+				.to_sym()
 				.await;
 			if let Ok(ReflMemKind::Const) = root.get_by_path(&new_name).await.map(|m| m.kind()) {
 				let Ok(mac) = h.exec::<TAtom<Macro>>(sym_ref(new_name)).await else { continue };
@@ -67,12 +67,7 @@ pub async fn resolve(val: MacTree) -> GExpr {
 		}
 		let mut rctx = ResolveCtx { h, exclusive, priod };
 		let gex = resolve_one(&mut rctx, Substack::Bottom, &val).await;
-		writeln!(
-			ctx.logger(),
-			"Macro-resolution over {}\nreturned {}",
-			fmt(&val, &i()).await,
-			fmt(&gex, &i()).await
-		);
+		writeln!(logger(), "Macro-resolution over {}\nreturned {}", fmt(&val).await, fmt(&gex).await);
 		gex
 	})
 	.await
@@ -110,7 +105,7 @@ async fn resolve_one(
 		MacTok::Lambda(arg, body) => {
 			let MacTok::Name(name) = &*arg.tok else {
 				return bot(mk_errv(
-					i().i("Syntax error after macros").await,
+					is("Syntax error after macros").await,
 					"This token ends up as a binding, consider replacing it with a name",
 					[arg.pos()],
 				));
@@ -121,8 +116,8 @@ async fn resolve_one(
 		},
 		MacTok::S(Paren::Round, body) => resolve_seq(ctx, arg_stk, body.clone(), value.pos()).await,
 		MacTok::S(..) => bot(mk_errv(
-			i().i("Leftover [] or {} not matched by macro").await,
-			format!("{} was not matched by any macro", fmt(value, &i()).await),
+			is("Leftover [] or {} not matched by macro").await,
+			format!("{} was not matched by any macro", fmt(value).await),
 			[value.pos()],
 		)),
 	}
@@ -150,7 +145,7 @@ async fn resolve_seq(
 ) -> GExpr {
 	if val.items.is_empty() {
 		return bot(mk_errv(
-			i().i("Empty sequence").await,
+			is("Empty sequence").await,
 			"() or (\\arg ) left after macro execution. \
 			This is usually caused by an incomplete call to a macro with bad error detection",
 			[fallback_pos],
@@ -224,7 +219,7 @@ async fn resolve_seq(
 				Err((lran, rran))
 			}
 		});
-		let mac_conflict_tk = i().i("Macro conflict").await;
+		let mac_conflict_tk = is("Macro conflict").await;
 		let error = conflict_sets
 			.filter(|r| 1 < r.len())
 			.map(|set| {
@@ -289,5 +284,5 @@ async fn mk_body_call(mac: &Macro, rule: &Rule, state: &MatchState<'_>, pos: Pos
 				MacTok::S(Paren::Round, MacTreeSeq::new(vec.iter().cloned())).at(Pos::None).to_gen().await,
 		});
 	}
-	call(sym_ref(mac.0.module.suffix([rule.body.clone()], &i()).await), call_args).at(pos.clone())
+	call(sym_ref(mac.0.module.suffix([rule.body.clone()]).await), call_args).at(pos.clone())
 }

orchid-std/src/macros/rule/build.rs

@@ -2,17 +2,16 @@ use futures::FutureExt;
 use futures::future::join_all;
 use itertools::Itertools;
 use orchid_base::error::{OrcRes, mk_errv};
-use orchid_base::interner::Tok;
+use orchid_base::interner::{IStr, is};
 use orchid_base::join_ok;
 use orchid_base::side::Side;
-use orchid_extension::context::i;
 
 use super::shared::{AnyMatcher, ScalMatcher, VecMatcher};
 use super::vec_attrs::vec_attrs;
 use crate::macros::mactree::{Ph, PhKind};
 use crate::macros::{MacTok, MacTree};
 
-pub type MaxVecSplit<'a> = (&'a [MacTree], (Tok<String>, u8, bool), &'a [MacTree]);
+pub type MaxVecSplit<'a> = (&'a [MacTree], (IStr, u8, bool), &'a [MacTree]);
 
 /// Derive the details of the central vectorial and the two sides from a
 /// slice of Expr's
@@ -126,7 +125,7 @@ async fn mk_scalar(pattern: &MacTree) -> OrcRes<ScalMatcher> {
 		MacTok::S(c, body) => ScalMatcher::S(*c, Box::new(mk_any(&body.items).boxed_local().await?)),
 		MacTok::Lambda(..) =>
 			return Err(mk_errv(
-				i().i("Lambda in matcher").await,
+				is("Lambda in matcher").await,
 				"Lambdas can't be matched for, only generated in templates",
 				[pattern.pos()],
 			)),
@@ -137,10 +136,11 @@ async fn mk_scalar(pattern: &MacTree) -> OrcRes<ScalMatcher> {
 
 #[cfg(test)]
 mod test {
+	use orchid_base::interner::local_interner::local_interner;
+	use orchid_base::interner::{is, with_interner};
 	use orchid_base::location::SrcRange;
 	use orchid_base::sym;
 	use orchid_base::tokens::Paren;
-	use orchid_extension::context::{i, mock_ctx, with_ctx};
 	use test_executors::spin_on;
 
 	use super::mk_any;
@@ -149,27 +149,27 @@ mod test {
 
 	#[test]
 	fn test_scan() {
-		spin_on(with_ctx(mock_ctx(), async {
-			let ex = |tok: MacTok| async { tok.at(SrcRange::mock(&i()).await.pos()) };
+		spin_on(with_interner(local_interner(), async {
+			let ex = |tok: MacTok| async { tok.at(SrcRange::mock().await.pos()) };
 			let pattern = vec![
 				ex(MacTok::Ph(Ph {
 					kind: PhKind::Vector { priority: 0, at_least_one: false },
-					name: i().i("::prefix").await,
+					name: is("::prefix").await,
 				}))
 				.await,
-				ex(MacTok::Name(sym!(prelude::do; i()))).await,
+				ex(MacTok::Name(sym!(prelude::do))).await,
 				ex(MacTok::S(
 					Paren::Round,
 					MacTreeSeq::new([
 						ex(MacTok::Ph(Ph {
 							kind: PhKind::Vector { priority: 0, at_least_one: false },
-							name: i().i("expr").await,
+							name: is("expr").await,
 						}))
 						.await,
-						ex(MacTok::Name(sym!(prelude::; ; i()))).await,
+						ex(MacTok::Name(sym!(prelude::;))).await,
 						ex(MacTok::Ph(Ph {
 							kind: PhKind::Vector { priority: 1, at_least_one: false },
-							name: i().i("rest").await,
+							name: is("rest").await,
 						}))
 						.await,
 					]),
@@ -177,7 +177,7 @@ mod test {
 				.await,
 				ex(MacTok::Ph(Ph {
 					kind: PhKind::Vector { priority: 0, at_least_one: false },
-					name: i().i("::suffix").await,
+					name: is("::suffix").await,
 				}))
 				.await,
 			];

orchid-std/src/macros/rule/matcher.rs

@@ -2,8 +2,8 @@ use std::fmt;
 use std::rc::Rc;
 
 use orchid_base::error::OrcRes;
+use orchid_base::interner::is;
 use orchid_base::name::Sym;
-use orchid_extension::context::i;
 
 use super::any_match::any_match;
 use super::build::mk_any;
@@ -24,12 +24,12 @@ impl Matcher {
 		let first = pattern.first().expect("Empty pattern is not allowed");
 		if vec_attrs(first).is_none() {
 			let pos = first.pos();
-			pattern.insert(0, MacTok::Ph(Ph { name: i().i("::before").await, kind }).at(pos));
+			pattern.insert(0, MacTok::Ph(Ph { name: is("::before").await, kind }).at(pos));
 		}
 		let last = pattern.last().expect("first returned Some above");
 		if vec_attrs(last).is_none() {
 			let pos = last.pos();
-			pattern.insert(0, MacTok::Ph(Ph { name: i().i("::after").await, kind }).at(pos));
+			pattern.insert(0, MacTok::Ph(Ph { name: is("::after").await, kind }).at(pos));
 		}
 		Ok(Matcher { inner: mk_any(&pattern).await? })
 	}
@@ -42,7 +42,7 @@ impl Matcher {
 	) -> Option<(&'a [MacTree], MatchState<'a>, &'a [MacTree])> {
 		let mut result = any_match(&self.inner, seq, &save_loc)?;
 		async fn remove_frame<'a>(result: &mut MatchState<'a>, key: &str) -> &'a [MacTree] {
-			match result.remove(i().i(key).await) {
+			match result.remove(is(key).await) {
 				Some(StateEntry::Scalar(_)) => panic!("{key} is defined in the constructor as a Vec"),
 				Some(StateEntry::Vec(v)) => v,
 				None => &[],

orchid-std/src/macros/rule/shared.rs

@@ -3,7 +3,7 @@
 use std::fmt;
 
 use itertools::Itertools;
-use orchid_base::interner::Tok;
+use orchid_base::interner::IStr;
 use orchid_base::name::Sym;
 use orchid_base::side::Side;
 use orchid_base::tokens::{PARENS, Paren};
@@ -11,12 +11,12 @@ use orchid_base::tokens::{PARENS, Paren};
 pub enum ScalMatcher {
 	Name(Sym),
 	S(Paren, Box<AnyMatcher>),
-	Placeh { key: Tok<String> },
+	Placeh { key: IStr },
 }
 
 pub enum VecMatcher {
 	Placeh {
-		key: Tok<String>,
+		key: IStr,
 		nonzero: bool,
 	},
 	Scan {
@@ -41,7 +41,7 @@ pub enum VecMatcher {
 		/// the length of matches on either side.
 		///
 		/// Vectorial keys that appear on either side, in priority order
-		key_order: Vec<Tok<String>>,
+		key_order: Vec<IStr>,
 	},
 }
 

orchid-std/src/macros/rule/state.rs

@@ -2,7 +2,7 @@
 use std::any::Any;
 
 use hashbrown::HashMap;
-use orchid_base::interner::Tok;
+use orchid_base::interner::IStr;
 use orchid_base::join::join_maps;
 use orchid_base::location::Pos;
 use orchid_base::match_mapping;
@@ -30,11 +30,11 @@ pub enum StateEntry<'a> {
 }
 #[derive(Clone, Debug)]
 pub struct MatchState<'a> {
-	placeholders: HashMap<Tok<String>, StateEntry<'a>>,
+	placeholders: HashMap<IStr, StateEntry<'a>>,
 	name_posv: HashMap<Sym, Vec<Pos>>,
 }
 impl<'a> MatchState<'a> {
-	pub fn from_ph(key: Tok<String>, entry: StateEntry<'a>) -> Self {
+	pub fn from_ph(key: IStr, entry: StateEntry<'a>) -> Self {
 		Self { placeholders: HashMap::from([(key, entry)]), name_posv: HashMap::new() }
 	}
 	pub fn combine(self, s: Self) -> Self {
@@ -45,7 +45,7 @@ impl<'a> MatchState<'a> {
 			}),
 		}
 	}
-	pub fn ph_len(&self, key: &Tok<String>) -> Option<usize> {
+	pub fn ph_len(&self, key: &IStr) -> Option<usize> {
 		match self.placeholders.get(key)? {
 			StateEntry::Vec(slc) => Some(slc.len()),
 			_ => None,
@@ -57,10 +57,8 @@ impl<'a> MatchState<'a> {
 	pub fn names(&self) -> impl Iterator<Item = (Sym, &[Pos])> {
 		self.name_posv.iter().map(|(sym, vec)| (sym.clone(), &vec[..]))
 	}
-	pub fn get(&self, key: &Tok<String>) -> Option<&StateEntry<'a>> { self.placeholders.get(key) }
-	pub fn remove(&mut self, name: Tok<String>) -> Option<StateEntry<'a>> {
-		self.placeholders.remove(&name)
-	}
+	pub fn get(&self, key: &IStr) -> Option<&StateEntry<'a>> { self.placeholders.get(key) }
+	pub fn remove(&mut self, name: IStr) -> Option<StateEntry<'a>> { self.placeholders.remove(&name) }
 	pub fn mk_owned(self) -> OwnedState {
 		OwnedState {
 			placeholders: (self.placeholders.into_iter())
@@ -88,10 +86,10 @@ pub enum OwnedEntry {
 	Scalar(MacTree),
 }
 pub struct OwnedState {
-	placeholders: HashMap<Tok<String>, OwnedEntry>,
+	placeholders: HashMap<IStr, OwnedEntry>,
 	name_posv: HashMap<Sym, Vec<Pos>>,
 }
 impl OwnedState {
-	pub fn get(&self, key: &Tok<String>) -> Option<&OwnedEntry> { self.placeholders.get(key) }
+	pub fn get(&self, key: &IStr) -> Option<&OwnedEntry> { self.placeholders.get(key) }
 	pub fn positions(&self, name: &Sym) -> &[Pos] { self.name_posv.get(name).map_or(&[], |v| &v[..]) }
 }

orchid-std/src/macros/rule/vec_attrs.rs

@@ -1,4 +1,4 @@
-use orchid_base::interner::Tok;
+use orchid_base::interner::IStr;
 
 use crate::macros::mactree::{Ph, PhKind};
 use crate::macros::{MacTok, MacTree};
@@ -6,7 +6,7 @@ use crate::macros::{MacTok, MacTree};
 /// Returns the name, priority and at_least_one of the expression if it is
 /// a vectorial placeholder
 #[must_use]
-pub fn vec_attrs(expr: &MacTree) -> Option<(Tok<String>, u8, bool)> {
+pub fn vec_attrs(expr: &MacTree) -> Option<(IStr, u8, bool)> {
 	match (*expr.tok).clone() {
 		MacTok::Ph(Ph { kind: PhKind::Vector { priority, at_least_one }, name }) =>
 			Some((name, priority, at_least_one)),

orchid-std/src/macros/std_macros.rs

@@ -3,7 +3,6 @@ use orchid_base::error::OrcRes;
 use orchid_base::sym;
 use orchid_extension::atom::TAtom;
 use orchid_extension::atom_owned::own;
-use orchid_extension::context::i;
 use orchid_extension::conv::ToExpr;
 use orchid_extension::coroutine_exec::exec;
 use orchid_extension::expr::Expr;
@@ -39,7 +38,7 @@ pub async fn gen_std_macro_lib() -> Vec<GenMember> {
 							Ok(MatcherAtom {
 								keys: sub.keys().collect().await,
 								matcher: h
-									.register(call(sym_ref(sym!(std::option::is_some_body; i())), [sub
+									.register(call(sym_ref(sym!(std::option::is_some_body)), [sub
 										.to_gen()
 										.await]))
 									.await,
@@ -51,7 +50,7 @@ pub async fn gen_std_macro_lib() -> Vec<GenMember> {
 					exec(async |mut h| {
 						Ok(MatcherAtom {
 							keys: vec![],
-							matcher: h.register(sym_ref(sym!(std::option::is_none_body; i()))).await,
+							matcher: h.register(sym_ref(sym!(std::option::is_none_body))).await,
 						})
 					})
 				}])
@@ -62,16 +61,16 @@ pub async fn gen_std_macro_lib() -> Vec<GenMember> {
 				.rule(mactreev!(std::tuple::t [ "...$" elements 0 ]), [|[elements]: [_; _]| {
 					exec(async move |mut h| {
 						let tup = h
-							.exec::<HomoTpl<TAtom<MacTree>>>(call(sym_ref(sym!(macros::resolve; i())), [
+							.exec::<HomoTpl<TAtom<MacTree>>>(call(sym_ref(sym!(macros::resolve)), [
 								mactree!((macros::common::comma_list "push" elements ;)).to_gen().await,
 							]))
 							.await?;
 						let val = stream::iter(&tup.0[..])
-							.fold(sym_ref(sym!(std::tuple::empty; i())), async |head, new| {
-								call(sym_ref(sym!(std::tuple::cat; i())), [
+							.fold(sym_ref(sym!(std::tuple::empty)), async |head, new| {
+								call(sym_ref(sym!(std::tuple::cat)), [
 									head,
-									call(sym_ref(sym!(std::tuple::one; i())), [call(
-										sym_ref(sym!(macros::resolve; i())),
+									call(sym_ref(sym!(std::tuple::one)), [call(
+										sym_ref(sym!(macros::resolve)),
 										[new.clone().to_gen().await],
 									)]),
 								])
@@ -102,7 +101,7 @@ pub async fn gen_std_macro_lib() -> Vec<GenMember> {
 fn parse_tpl(elements: MacTree, tail_matcher: Option<MacTree>) -> impl Future<Output = GExpr> {
 	exec(async move |mut h| -> OrcRes<MatcherAtom> {
 		let tup = h
-			.exec::<HomoTpl<TAtom<MacTree>>>(call(sym_ref(sym!(macros::resolve; i())), [
+			.exec::<HomoTpl<TAtom<MacTree>>>(call(sym_ref(sym!(macros::resolve)), [
 				mactree!((macros::common::comma_list "push" elements ;)).to_gen().await,
 			]))
 			.await?;
@@ -110,7 +109,7 @@ fn parse_tpl(elements: MacTree, tail_matcher: Option<MacTree>) -> impl Future<Ou
 		for mac_a in &tup.0[..] {
 			let mac = own(mac_a).await;
 			let sub = h
-				.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve; i())), [
+				.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve)), [
 					mactree!(pattern::match_rule ("push" mac ;)).to_gen().await,
 				]))
 				.await?;
@@ -118,7 +117,7 @@ fn parse_tpl(elements: MacTree, tail_matcher: Option<MacTree>) -> impl Future<Ou
 		}
 		let tail_matcher = match tail_matcher {
 			Some(mac) => Some(
-				h.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve; i())), [
+				h.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve)), [
 					mactree!(pattern::match_rule "push" mac ;).to_gen().await,
 				]))
 				.await?,
@@ -131,7 +130,7 @@ fn parse_tpl(elements: MacTree, tail_matcher: Option<MacTree>) -> impl Future<Ou
 				.chain(stream::iter(&tail_matcher).flat_map(|mat| mat.keys()))
 				.collect()
 				.await,
-			matcher: call(sym_ref(sym!(std::tuple::matcher_body; i())), [
+			matcher: call(sym_ref(sym!(std::tuple::matcher_body)), [
 				HomoTpl(subs).to_gen().await,
 				OrcOpt(tail_matcher).to_gen().await,
 			])
@@ -162,8 +161,8 @@ fn tuple_matcher_body(
 			None => (),
 			Some(tail_mat) => {
 				let tail_tpl = stream::iter(&value.0[children.0.len()..])
-					.fold(sym_ref(sym!(std::tuple::empty; i())), async |prefix, new| {
-						call(sym_ref(sym!(std::tuple::cat; i())), [prefix, new.clone().to_gen().await])
+					.fold(sym_ref(sym!(std::tuple::empty)), async |prefix, new| {
+						call(sym_ref(sym!(std::tuple::cat)), [prefix, new.clone().to_gen().await])
 					})
 					.await;
 				match tail_mat.run_matcher(&mut h, tail_tpl).await? {

orchid-std/src/macros/utils.rs

@@ -6,10 +6,10 @@ use futures::StreamExt;
 use futures::future::LocalBoxFuture;
 use itertools::{Itertools, chain};
 use never::Never;
+use orchid_base::interner::is;
 use orchid_base::name::{NameLike, Sym, VPath};
 use orchid_extension::atom::{Atomic, TAtom};
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant, own};
-use orchid_extension::context::i;
 use orchid_extension::conv::ToExpr;
 use orchid_extension::gen_expr::{GExpr, sym_ref};
 use orchid_extension::tree::{GenMember, MemKind, cnst, lazy};
@@ -101,11 +101,11 @@ impl MacroBuilder {
 		let Self { own_kws, prio, patterns, body_consts } = self;
 		let name = own_kws[0];
 		let main_const = lazy(true, &format!("__macro__{name}"), async move |path| {
-			let module = (Sym::new(path.split_last_seg().1.iter().cloned(), &i()).await)
+			let module = (Sym::new(path.split_last_seg().1.iter().cloned()).await)
 				.expect("Default macro in global root");
 			MemKind::Const(
 				Macro(Rc::new(MacroData {
-					canonical_name: module.suffix([i().i(name).await], &i()).await,
+					canonical_name: module.suffix([is(name).await]).await,
 					module,
 					prio,
 					rules: stream(async |mut h| {
@@ -121,7 +121,7 @@ impl MacroBuilder {
 								matcher: Matcher::new(pattern.clone()).await.unwrap(),
 								pattern,
 								ph_names: placeholders,
-								body: i().i(&format!("({name})::{counter}")).await,
+								body: is(&format!("({name})::{counter}")).await,
 							})
 							.await;
 						}
@@ -136,8 +136,8 @@ impl MacroBuilder {
 		let kw_consts = own_kws[1..].iter().flat_map(|kw| {
 			lazy(true, &format!("__macro__{kw}"), async move |path| {
 				let main_const_name = VPath::new(path.split_last_seg().1.iter().cloned())
-					.name_with_suffix(i().i(&format!("__macro__{name}")).await)
-					.to_sym(&i())
+					.name_with_suffix(is(&format!("__macro__{name}")).await)
+					.to_sym()
 					.await;
 				MemKind::Const(sym_ref(main_const_name))
 			})
@@ -156,21 +156,21 @@ macro_rules! mactreev_impl {
 	(@RECUR $ret:ident) => {};
 	(@RECUR $ret:ident "..$" $name:ident $prio:literal $($tail:tt)*) => {
 		$ret.push($crate::macros::mactree::MacTok::Ph($crate::macros::mactree::Ph{
-			name: orchid_extension::context::i().i(stringify!($name)).await,
+			name: orchid_base::interner::is(stringify!($name)).await,
 			kind: $crate::macros::mactree::PhKind::Vector{ at_least_one: false, priority: $prio }
 		}).at(orchid_base::location::Pos::Inherit));
 		$crate::macros::utils::mactreev_impl!(@RECUR $ret $($tail)*);
 	};
 	(@RECUR $ret:ident "...$" $name:ident $prio:literal $($tail:tt)*) => {
 		$ret.push($crate::macros::mactree::MacTok::Ph($crate::macros::mactree::Ph{
-			name: orchid_extension::context::i().i(stringify!($name)).await,
+			name: orchid_base::interner::is(stringify!($name)).await,
 			kind: $crate::macros::mactree::PhKind::Vector{ at_least_one: true, priority: $prio }
 		}).at(orchid_base::location::Pos::Inherit));
 		$crate::macros::utils::mactreev_impl!(@RECUR $ret $($tail)*);
 	};
 	(@RECUR $ret:ident "$" $name:ident $($tail:tt)*) => {
 		$ret.push($crate::macros::mactree::MacTok::Ph($crate::macros::mactree::Ph{
-			name: orchid_extension::context::i().i(stringify!(name)).await,
+			name: orchid_base::interner::is(stringify!(name)).await,
 			kind: $crate::macros::mactree::PhKind::Scalar
 		}).at(orchid_base::location::Pos::Inherit));
 		$crate::macros::utils::mactreev_impl!(@RECUR $ret $($tail)*);
@@ -195,7 +195,7 @@ macro_rules! mactreev_impl {
 	};
 	(@RECUR $ret:ident "l" $argh:tt $(:: $arg:tt)+ ($($body:tt)*) $($tail:tt)*) => {
 		$ret.push(MacTok::Lambda(
-			MacTok::Name(sym!($argh $(:: $arg)+; orchid_extension::context::i()).await).at(orchid_base::location::Pos::Inherit),
+			MacTok::Name(sym!($argh $(:: $arg)+).await).at(orchid_base::location::Pos::Inherit),
 			$crate::macros::utils::mactreev!($($body)*)
 		).at(orchid_base::location::Pos::Inherit));
 		$crate::macros::utils::mactreev_impl!(@RECUR $ret $($tail)*);
@@ -207,8 +207,7 @@ macro_rules! mactreev_impl {
 			$name
 		);
 		let sym = orchid_base::name::Sym::parse(
-			$name,
-			&orchid_extension::context::i()
+			$name
 		).await.expect("Empty string in sym literal in Rust");
 		$ret.push(
 			$crate::macros::mactree::MacTok::Name(sym)
@@ -253,7 +252,7 @@ macro_rules! mactreev_impl {
 		$crate::macros::utils::mactreev_impl!(@NAME_MUNCHER $ret ($($munched)* :: $name) $($tail)*)
 	};
 	(@NAME_MUNCHER $ret:ident ($($munched:tt)*) $($tail:tt)*) => {
-		let sym = orchid_base::sym!($($munched)* ; orchid_extension::context::i());
+		let sym = orchid_base::sym!($($munched)*);
 		$ret.push(
 			$crate::macros::mactree::MacTok::Name(sym)
 				.at(orchid_base::location::Pos::Inherit)