Parsing!

orchid-base/src/format.rs

@@ -102,6 +102,12 @@ pub struct Variant {
 	pub elements: Vec<FmtElement>,
 }
 
+#[test]
+fn variants_parse_test() {
+	let vars = Variants::default().bounded("({0})");
+	println!("final: {vars:?}")
+}
+
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Default)]
 pub struct Variants(pub Vec<Variant>);
 impl Variants {
@@ -126,7 +132,7 @@ impl Variants {
 			let idx = num.parse::<u32>().expect("Decimal digits required by regex");
 			(tpl.range(), idx, bounded)
 		});
-		(iter::once(None).chain(slots.into_iter().map(Some)).chain(None).tuple_windows())
+		(iter::once(None).chain(slots.into_iter().map(Some)).chain([None]).tuple_windows())
 			.flat_map(|(l, r)| {
 				let string = match (l, &r) {
 					(None, Some((r, ..))) => &s[..r.start],

orchid-base/src/macros.rs

@@ -52,7 +52,7 @@ impl<'a, A> MTree<'a, A> {
 }
 impl<A: Format> Format for MTree<'_, A> {
 	async fn print<'a>(&'a self, c: &'a (impl FmtCtx + ?Sized + 'a)) -> FmtUnit {
-		self.tok.print(c).await
+		self.tok.print(c).boxed_local().await
 	}
 }
 
@@ -108,7 +108,7 @@ impl<A: Format> Format for MTok<'_, A> {
 			Self::Atom(a) => a.print(c).await,
 			Self::Done(d) =>
 				FmtUnit::new(tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("(Done){0l}"))), [
-					d.print(c).await,
+					d.print(c).boxed_local().await,
 				]),
 			Self::Lambda(arg, b) => FmtUnit::new(
 				tl_cache!(Rc<Variants>: Rc::new(Variants::default()
@@ -120,7 +120,7 @@ impl<A: Format> Format for MTok<'_, A> {
 			Self::Ph(ph) => format!("{ph}").into(),
 			Self::Ref(r) =>
 				FmtUnit::new(tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("(ref){0l}"))), [
-					r.print(c).await,
+					r.print(c).boxed_local().await,
 				]),
 			Self::S(p, body) => FmtUnit::new(
 				match *p {

orchid-base/src/tree.rs

@@ -262,9 +262,9 @@ impl<A: AtomRepr, X: ExtraTok> Format for Token<'_, A, X> {
 			Self::Ph(ph) => format!("{ph}").into(),
 			Self::S(p, b) => FmtUnit::new(
 				match *p {
-					Paren::Round => Rc::new(Variants::default().bounded("({0b})")),
+					Paren::Round => tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("({0b})"))),
-					Paren::Curly => Rc::new(Variants::default().bounded("{{{0b}}}")),
+					Paren::Curly => tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("{{{0b}}}"))),
-					Paren::Square => Rc::new(Variants::default().bounded("[{0b}]")),
+					Paren::Square => tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("[{0b}]"))),
 				},
 				[ttv_fmt(b, c).await],
 			),

orchid-host/src/expr.rs

@@ -76,19 +76,24 @@ impl Format for Expr {
 				ExprKind::Call(f, x) => tl_cache!(Rc<Variants>: Rc::new(Variants::default()
 					.unbounded("{0} {1l}")
 					.bounded("({0} {1b})")))
-				.units([f.print(c).await, x.print(c).await]),
+				.units([
+					print_expr(f, c, visited).boxed_local().await,
+					print_expr(x, c, visited).boxed_local().await,
+				]),
 				ExprKind::Const(c) => format!("{c}").into(),
 				ExprKind::Lambda(None, body) => tl_cache!(Rc<Variants>: Rc::new(Variants::default()
 					.unbounded("\\.{0l}")
 					.bounded("(\\.{0b})")))
-				.units([body.print(c).await]),
+				.units([print_expr(body, c, visited).boxed_local().await]),
 				ExprKind::Lambda(Some(path), body) => tl_cache!(Rc<Variants>: Rc::new(Variants::default()
 					.unbounded("\\{0b}. {1l}")
 					.bounded("(\\{0b}. {1b})")))
-				.units([format!("{path}").into(), body.print(c).await]),
+				.units([format!("{path}").into(), print_expr(body, c, visited).boxed_local().await]),
 				ExprKind::Seq(l, r) =>
-					tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("[{0b}]{1l}")))
+					tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("[{0b}]{1l}"))).units([
-						.units([l.print(c).await, r.print(c).await]),
+						print_expr(l, c, visited).boxed_local().await,
+						print_expr(r, c, visited).boxed_local().await,
+					]),
 			}
 		}
 	}

orchid-host/src/tree.rs

@@ -91,6 +91,15 @@ impl Format for Item {
 				tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("macro {{\n\t{0}\n}}")))
 					.units([Variants::sequence(rules.len(), "\n", None)
 						.units(join_all(rules.iter().map(|r| r.print(c))).await)]),
+			ItemKind::Member(mem) => match mem.kind.get() {
+				None => format!("lazy {}", mem.name).into(),
+				Some(MemberKind::Const(val)) =>
+					tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("const {0} = {1}")))
+						.units([mem.name.rc().into(), val.print(c).await]),
+				Some(MemberKind::Mod(module)) =>
+					tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("module {0} {{\n\t{1}\n}}")))
+						.units([mem.name.rc().into(), module.print(c).boxed_local().await]),
+			},
 			_ => panic!(),
 		};
 		tl_cache!(Rc<Variants>: Rc::new(Variants::default().bounded("{0}\n{1}")))
@@ -164,6 +173,15 @@ impl Module {
 		)
 	}
 }
+impl Format for Module {
+	async fn print<'a>(&'a self, c: &'a (impl FmtCtx + ?Sized + 'a)) -> FmtUnit {
+		let import_str = self.imports.iter().map(|i| format!("import {i}")).join("\n");
+		let head_str = format!("{import_str}\nexport ::({})\n", self.exports.iter().join(", "));
+		Variants::sequence(self.items.len() + 1, "\n", None).units(
+			[head_str.into()].into_iter().chain(join_all(self.items.iter().map(|i| i.print(c))).await),
+		)
+	}
+}
 
 pub struct LazyMemberHandle(api::TreeId, System, Vec<Tok<String>>);
 impl LazyMemberHandle {

orcx/src/main.rs

@@ -10,7 +10,7 @@ use clap::{Parser, Subcommand};
 use futures::{Stream, TryStreamExt, io};
 use orchid_base::clone;
 use orchid_base::error::ReporterImpl;
-use orchid_base::format::{FmtCtxImpl, take_first};
+use orchid_base::format::{FmtCtxImpl, Format, take_first};
 use orchid_base::logging::{LogStrategy, Logger};
 use orchid_base::parse::Snippet;
 use orchid_base::tree::ttv_fmt;
@@ -111,7 +111,7 @@ async fn main() -> io::Result<ExitCode> {
 						return;
 					}
 					for item in ptree {
-						println!("{item:?}")
+						println!("{}", take_first(&item.print(&FmtCtxImpl { i: &ctx.i }).await, true))
 					}
 				},
 			}