Temporary commit to try fix halting

orchid-std/src/macros/let_line.rs

@@ -39,7 +39,7 @@ impl Parser for LetLine {
 			let rep = Reporter::new();
 			let dealiased = dealias_mac_v(aliased, &ctx, &rep).await;
 			let macro_input = MacTok::S(Paren::Round, dealiased).at(sr.pos());
-			if let Some(e) = rep.errv() {
+			if let Some(e) = rep.res() {
 				return Err(e);
 			}
 			Ok(call([

orchid-std/src/macros/macro_lib.rs

@@ -40,7 +40,7 @@ pub fn gen_macro_lib() -> Vec<GenMember> {
 		fun(true, "lower", |tpl: TypAtom<MacTree>| async move {
 			let ctx = LowerCtx { sys: tpl.untyped.ctx().clone(), rep: &Reporter::new() };
 			let res = own(tpl).await.lower(ctx, Substack::Bottom).await;
-			if let Some(e) = Reporter::new().errv() { Err(e) } else { Ok(res) }
+			if let Some(e) = Reporter::new().res() { Err(e) } else { Ok(res) }
 		}),
 		fun(true, "resolve_recur", |state: TypAtom<RecurState>, tpl: TypAtom<MacTree>| async move {
 			exec("macros::resolve_recur", async move |mut h| {

orchid-std/src/macros/macro_line.rs

@@ -7,7 +7,7 @@ use futures::{StreamExt, stream};
 use hashbrown::{HashMap, HashSet};
 use itertools::Itertools;
 use never::Never;
-use orchid_base::error::{OrcRes, Reporter, mk_errv};
+use orchid_base::error::{OrcRes, Reporter, mk_err};
 use orchid_base::interner::Tok;
 use orchid_base::location::Pos;
 use orchid_base::name::Sym;
@@ -40,7 +40,7 @@ impl Parser for MacroLine {
 		line: PSnippet<'a>,
 	) -> OrcRes<Vec<ParsedLine>> {
 		if exported {
-			return Err(mk_errv(
+			return Err(mk_err(
 				ctx.i().i("macros are always exported").await,
 				"The export keyword is forbidden here to avoid confusion\n\
 					because macros are exported by default",
@@ -94,7 +94,7 @@ impl Parser for MacroLine {
 			}
 		}
 		let Some(macro_name) = keywords.keys().next().cloned() else {
-			return Err(mk_errv(
+			return Err(mk_err(
 				ctx.i().i("macro with no keywords").await,
 				"Macros must define at least one macro of their own.",
 				[kw_line.tail.sr()],
@@ -109,7 +109,7 @@ impl Parser for MacroLine {
 			let Parsed { tail, .. } = expect_tok(&ctx, line.tail, ctx.i().i("rule").await).await?;
 			let arrow_token = ctx.i().i("=>").await;
 			let Some((pattern, body)) = tail.split_once(|tok| tok.is_kw(arrow_token.clone())) else {
-				ctx.rep().report(mk_errv(
+				ctx.rep().report(mk_err(
 					ctx.i().i("Missing => in rule").await,
 					"Rule lines are of the form `rule ...pattern => ...body`",
 					[line.tail.sr()],
@@ -137,7 +137,7 @@ impl Parser for MacroLine {
 				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() {
+				if let Some(e) = rep.res() {
 					return Err(e);
 				}
 				Ok(call([
@@ -199,7 +199,7 @@ pub struct MacroData {
 	pub module: Sym,
 	pub prio: Option<u64>,
 	pub rules: Vec<Rule>,
-	pub own_kws: Vec<Tok<String>>,
+	pub own_kws: Vec<IStr>,
 }
 
 #[derive(Clone, Debug)]
@@ -210,8 +210,8 @@ pub struct Rule {
 	pub pos: Pos,
 	pub pattern: Matcher,
 	pub glossary: HashSet<Sym>,
-	pub placeholders: Vec<Tok<String>>,
-	pub body_name: Tok<String>,
+	pub placeholders: Vec<IStr>,
+	pub body_name: IStr,
 }
 #[derive(Debug)]
 pub enum Matcher {

orchid-std/src/macros/mactree.rs

@@ -6,7 +6,7 @@ use futures::FutureExt;
 use futures::future::join_all;
 use hashbrown::HashSet;
 use itertools::Itertools;
-use orchid_base::error::{OrcErrv, Reporter, mk_errv};
+use orchid_base::error::{OrcErrv, Reporter, mk_err};
 use orchid_base::format::{FmtCtx, FmtUnit, Format, Variants, fmt};
 use orchid_base::interner::Tok;
 use orchid_base::location::Pos;
@@ -42,7 +42,7 @@ impl MacTree {
 			MacTok::Bottom(e) => bot(e.clone()),
 			MacTok::Lambda(arg, body) => {
 				let MacTok::Name(name) = &*arg.tok else {
-					let err = mk_errv(
+					let err = mk_err(
 						ctx.sys.i().i("Syntax error after macros").await,
 						"This token ends up as a binding, consider replacing it with a name",
 						[arg.pos()],
@@ -57,7 +57,7 @@ impl MacTree {
 				Some((i, _)) => arg((args.len() - i) as u64),
 			},
 			MacTok::Ph(ph) => {
-				let err = mk_errv(
+				let err = mk_err(
 					ctx.sys.i().i("Placeholder in value").await,
 					format!("Placeholder {ph} is only supported in macro patterns"),
 					[self.pos()],
@@ -67,7 +67,7 @@ impl MacTree {
 			},
 			MacTok::S(Paren::Round, body) => call(lower_v(body, ctx, args).await),
 			MacTok::S(..) => {
-				let err = mk_errv(
+				let err = mk_err(
 					ctx.sys.i().i("[] or {} after macros").await,
 					format!("{} didn't match any macro", fmt(self, ctx.sys.i()).await),
 					[self.pos()],
@@ -166,7 +166,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

@@ -1,7 +1,7 @@
 use std::ops::RangeInclusive;
 
 use futures::FutureExt;
-use orchid_base::error::{OrcRes, mk_errv};
+use orchid_base::error::{OrcRes, mk_err};
 use orchid_base::parse::ParseCtx;
 use orchid_base::sym;
 use orchid_base::tokens::PARENS;
@@ -55,7 +55,7 @@ impl Lexer for MacTreeLexer {
 					if let Some(tail3) = tail2.strip_prefix(*rp) {
 						break Ok((tail3, MacTok::S(*paren, items).at(ctx.pos_tt(tail, tail3).pos())));
 					} else if tail2.is_empty() {
-						return Err(mk_errv(
+						return Err(mk_err(
 							ctx.i().i("Unclosed block").await,
 							format!("Expected closing {rp}"),
 							[ctx.pos_lt(1, tail)],

orchid-std/src/macros/recur_state.rs

@@ -11,7 +11,7 @@ use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant};
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct RulePath {
 	pub module: Sym,
-	pub main_kw: Tok<String>,
+	pub main_kw: IStr,
 	pub rule: u32,
 }
 impl RulePath {

orchid-std/src/macros/resolve.rs

@@ -1,7 +1,7 @@
 use futures::FutureExt;
 use hashbrown::HashMap;
 use itertools::Itertools;
-use orchid_base::error::mk_errv;
+use orchid_base::error::mk_err;
 use orchid_base::location::Pos;
 use orchid_base::name::Sym;
 use orchid_base::sym;
@@ -91,7 +91,7 @@ async fn mk_body_call(
 	let rule_path =
 		RulePath { module: mac.0.module.clone(), main_kw: mac.0.own_kws[0].clone(), rule: rule.index };
 	let Some(new_recur) = recur.push(rule_path.clone()) else {
-		return bot(mk_errv(
+		return bot(mk_err(
 			ctx.i().i("Circular macro dependency").await,
 			format!("The definition of {rule_path} is circular"),
 			[rule.pos.clone()],

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

@@ -1,7 +1,7 @@
 use futures::FutureExt;
 use futures::future::join_all;
 use itertools::Itertools;
-use orchid_base::error::{OrcRes, mk_errv};
+use orchid_base::error::{OrcRes, mk_err};
 use orchid_base::interner::{Interner, Tok};
 use orchid_base::join_ok;
 use orchid_base::side::Side;
@@ -11,7 +11,7 @@ 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
@@ -124,7 +124,7 @@ async fn mk_scalar(pattern: &MacTree, i: &Interner) -> OrcRes<ScalMatcher> {
 		},
 		MacTok::S(c, body) => ScalMatcher::S(*c, Box::new(mk_any(body, i).boxed_local().await?)),
 		MacTok::Lambda(..) =>
-			return Err(mk_errv(
+			return Err(mk_err(
 				i.i("Lambda in matcher").await,
 				"Lambdas can't be matched for, only generated in templates",
 				[pattern.pos()],

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

@@ -18,7 +18,7 @@ use crate::macros::{MacTok, MacTree};
 pub struct NamedMatcher {
 	inner: AnyMatcher,
 	head: Sym,
-	after_tok: Tok<String>,
+	after_tok: IStr,
 }
 impl NamedMatcher {
 	pub async fn new(pattern: &[MacTree], i: &Interner) -> OrcRes<Self> {

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

@@ -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

@@ -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,
@@ -54,8 +54,8 @@ impl<'a> MatchState<'a> {
 	pub fn from_name(name: Sym, location: Pos) -> Self {
 		Self { name_posv: HashMap::from([(name, vec![location])]), placeholders: HashMap::new() }
 	}
-	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>> {
+	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 {
@@ -85,10 +85,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

@@ -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/std/string/str_atom.rs

@@ -6,7 +6,7 @@ use std::rc::Rc;
 use futures::AsyncWrite;
 use orchid_api_derive::Coding;
 use orchid_api_traits::{Encode, Request};
-use orchid_base::error::{OrcRes, mk_errv};
+use orchid_base::error::{OrcRes, mk_err};
 use orchid_base::format::{FmtCtx, FmtUnit};
 use orchid_base::interner::Tok;
 use orchid_extension::atom::{AtomMethod, Atomic, MethodSetBuilder, Supports, TypAtom};
@@ -58,13 +58,13 @@ impl OwnedAtom for StrAtom {
 }
 
 #[derive(Debug, Clone)]
-pub struct IntStrAtom(Tok<String>);
+pub struct IntStrAtom(IStr);
 impl Atomic for IntStrAtom {
 	type Variant = OwnedVariant;
 	type Data = orchid_api::TStr;
 }
-impl From<Tok<String>> for IntStrAtom {
-	fn from(value: Tok<String>) -> Self { Self(value) }
+impl From<IStr> for IntStrAtom {
+	fn from(value: IStr) -> Self { Self(value) }
 }
 impl OwnedAtom for IntStrAtom {
 	type Refs = ();
@@ -109,7 +109,7 @@ impl TryFromExpr for OrcString {
 		let ctx = expr.ctx();
 		match TypAtom::<IntStrAtom>::try_from_expr(expr).await {
 			Ok(t) => Ok(OrcString { ctx: t.untyped.ctx().clone(), kind: OrcStringKind::Int(t) }),
-			Err(e) => Err(mk_errv(ctx.i().i("A string was expected").await, "", e.pos_iter())),
+			Err(e) => Err(mk_err(ctx.i().i("A string was expected").await, "", e.pos_iter())),
 		}
 	}
 }

orchid-std/src/std/string/str_lexer.rs

@@ -1,5 +1,5 @@
 use itertools::Itertools;
-use orchid_base::error::{OrcErr, OrcErrv, OrcRes, mk_errv};
+use orchid_base::error::{OrcErr, OrcErrv, OrcRes, mk_err};
 use orchid_base::interner::Interner;
 use orchid_base::location::SrcRange;
 use orchid_base::name::Sym;
@@ -36,7 +36,7 @@ impl StringError {
 	/// Convert into project error for reporting
 	pub async fn into_proj(self, path: &Sym, pos: u32, i: &Interner) -> OrcErrv {
 		let start = pos + self.pos;
-		mk_errv(
+		mk_err(
 			i.i("Failed to parse string").await,
 			match self.kind {
 				StringErrorKind::NotHex => "Expected a hex digit",
@@ -144,7 +144,7 @@ impl Lexer for StringLexer {
 					tail = ch.as_str();
 				} else {
 					let range = ctx.pos(all)..ctx.pos("");
-					return Err(mk_errv(
+					return Err(mk_err(
 						ctx.i().i("No string end").await,
 						"String never terminated with \"",
 						[SrcRange::new(range.clone(), ctx.src())],