New macro system and stdlib additions

orchid-extension/src/tree.rs

@@ -14,19 +14,19 @@ use substack::Substack;
 use trait_set::trait_set;
 
 use crate::api;
+use crate::context::i;
 use crate::conv::ToExpr;
 use crate::entrypoint::MemberRecord;
 use crate::expr::{BorrowedExprStore, Expr, ExprHandle};
 use crate::func_atom::{ExprFunc, Fun};
 use crate::gen_expr::{GExpr, sym_ref};
-use crate::system::SysCtx;
 
 pub type GenTokTree = TokTree<Expr, GExpr>;
 pub type GenTok = Token<Expr, GExpr>;
 
 impl TokenVariant<api::Expression> for GExpr {
 	type FromApiCtx<'a> = ();
-	type ToApiCtx<'a> = SysCtx;
+	type ToApiCtx<'a> = ();
 	async fn from_api(
 		_: &api::Expression,
 		_: &mut Self::FromApiCtx<'_>,
@@ -35,33 +35,31 @@ impl TokenVariant<api::Expression> for GExpr {
 	) -> Self {
 		panic!("Received new expression from host")
 	}
-	async fn into_api(self, ctx: &mut Self::ToApiCtx<'_>) -> api::Expression {
-		self.api_return(ctx.clone()).await
-	}
+	async fn into_api(self, _: &mut Self::ToApiCtx<'_>) -> api::Expression { self.serialize().await }
 }
 
 impl TokenVariant<api::ExprTicket> for Expr {
-	type FromApiCtx<'a> = (SysCtx, &'a BorrowedExprStore);
+	type FromApiCtx<'a> = &'a BorrowedExprStore;
 	async fn from_api(
 		api: &api::ExprTicket,
-		(ctx, exprs): &mut Self::FromApiCtx<'_>,
+		exprs: &mut Self::FromApiCtx<'_>,
 		_: SrcRange,
 		_: &Interner,
 	) -> Self {
 		// SAFETY: receiving trees from sublexers implies borrowing
-		Expr::from_handle(ExprHandle::borrowed(ctx.clone(), *api, exprs))
+		Expr::from_handle(ExprHandle::borrowed(*api, exprs))
 	}
 	type ToApiCtx<'a> = ();
-	async fn into_api(self, (): &mut Self::ToApiCtx<'_>) -> api::ExprTicket { self.handle().tk }
+	async fn into_api(self, (): &mut Self::ToApiCtx<'_>) -> api::ExprTicket { self.handle().ticket() }
 }
 
-pub async fn x_tok(x: impl ToExpr) -> GenTok { GenTok::NewExpr(x.to_expr().await) }
+pub async fn x_tok(x: impl ToExpr) -> GenTok { GenTok::NewExpr(x.to_gen().await) }
 pub async fn ref_tok(path: Sym) -> GenTok { GenTok::NewExpr(sym_ref(path)) }
 
 pub fn lazy(
 	public: bool,
 	name: &str,
-	cb: impl AsyncFnOnce(Sym, SysCtx) -> MemKind + Clone + 'static,
+	cb: impl AsyncFnOnce(Sym) -> MemKind + Clone + 'static,
 ) -> Vec<GenMember> {
 	vec![GenMember {
 		name: name.to_string(),
@@ -71,7 +69,7 @@ pub fn lazy(
 	}]
 }
 pub fn cnst(public: bool, name: &str, value: impl ToExpr + Clone + 'static) -> Vec<GenMember> {
-	lazy(public, name, async |_, _| MemKind::Const(value.to_expr().await))
+	lazy(public, name, async |_| MemKind::Const(value.to_gen().await))
 }
 pub fn module(
 	public: bool,
@@ -86,8 +84,8 @@ pub fn root_mod(name: &str, mems: impl IntoIterator<Item = Vec<GenMember>>) -> (
 	(name.to_string(), kind)
 }
 pub fn fun<I, O>(public: bool, name: &str, xf: impl ExprFunc<I, O>) -> Vec<GenMember> {
-	let fac = LazyMemberFactory::new(async move |sym, ctx| {
-		MemKind::Const(Fun::new(sym, ctx, xf).await.to_expr().await)
+	let fac = LazyMemberFactory::new(async move |sym| {
+		MemKind::Const(Fun::new(sym, xf).await.to_gen().await)
 	});
 	vec![GenMember { name: name.to_string(), kind: MemKind::Lazy(fac), public, comments: vec![] }]
 }
@@ -149,14 +147,14 @@ pub fn merge_trivial(trees: impl IntoIterator<Item = Vec<GenMember>>) -> Vec<Gen
 
 trait_set! {
 	trait LazyMemberCallback =
-		FnOnce(Sym, SysCtx) -> LocalBoxFuture<'static, MemKind> + DynClone
+		FnOnce(Sym) -> LocalBoxFuture<'static, MemKind> + DynClone
 }
 pub struct LazyMemberFactory(Box<dyn LazyMemberCallback>);
 impl LazyMemberFactory {
-	pub fn new(cb: impl AsyncFnOnce(Sym, SysCtx) -> MemKind + Clone + 'static) -> Self {
-		Self(Box::new(|s, ctx| cb(s, ctx).boxed_local()))
+	pub fn new(cb: impl AsyncFnOnce(Sym) -> MemKind + Clone + 'static) -> Self {
+		Self(Box::new(|s| cb(s).boxed_local()))
 	}
-	pub async fn build(self, path: Sym, ctx: SysCtx) -> MemKind { (self.0)(path, ctx).await }
+	pub async fn build(self, path: Sym) -> MemKind { (self.0)(path).await }
 }
 impl Clone for LazyMemberFactory {
 	fn clone(&self) -> Self { Self(clone_box(&*self.0)) }
@@ -169,11 +167,10 @@ pub struct GenMember {
 	pub comments: Vec<String>,
 }
 impl GenMember {
-	pub async fn into_api(self, ctx: &mut impl TreeIntoApiCtx) -> api::Member {
-		let name = ctx.sys().i().i::<String>(&self.name).await;
-		let kind = self.kind.into_api(&mut ctx.push_path(name.clone())).await;
-		let comments =
-			join_all(self.comments.iter().map(async |cmt| ctx.sys().i().i(cmt).await.to_api())).await;
+	pub async fn into_api(self, tia_cx: &mut impl TreeIntoApiCtx) -> api::Member {
+		let name = i().i::<String>(&self.name).await;
+		let kind = self.kind.into_api(&mut tia_cx.push_path(name.clone())).await;
+		let comments = join_all(self.comments.iter().map(async |cmt| i().i(cmt).await.to_api())).await;
 		api::Member { kind, name: name.to_api(), comments, exported: self.public }
 	}
 }
@@ -187,7 +184,7 @@ impl MemKind {
 	pub async fn into_api(self, ctx: &mut impl TreeIntoApiCtx) -> api::MemberKind {
 		match self {
 			Self::Lazy(lazy) => api::MemberKind::Lazy(ctx.with_lazy(lazy)),
-			Self::Const(c) => api::MemberKind::Const(c.api_return(ctx.sys()).await),
+			Self::Const(c) => api::MemberKind::Const(c.serialize().await),
 			Self::Mod { members } => api::MemberKind::Module(api::Module {
 				members: stream(async |mut cx| {
 					for m in members {
@@ -203,24 +200,20 @@ impl MemKind {
 }
 
 pub trait TreeIntoApiCtx {
-	fn sys(&self) -> SysCtx;
 	fn with_lazy(&mut self, fac: LazyMemberFactory) -> api::TreeId;
 	fn push_path(&mut self, seg: Tok<String>) -> impl TreeIntoApiCtx;
 }
 
 pub struct TreeIntoApiCtxImpl<'a, 'b> {
-	pub sys: SysCtx,
 	pub basepath: &'a [Tok<String>],
 	pub path: Substack<'a, Tok<String>>,
 	pub lazy_members: &'b mut HashMap<api::TreeId, MemberRecord>,
 }
 
 impl TreeIntoApiCtx for TreeIntoApiCtxImpl<'_, '_> {
-	fn sys(&self) -> SysCtx { self.sys.clone() }
 	fn push_path(&mut self, seg: Tok<String>) -> impl TreeIntoApiCtx {
 		TreeIntoApiCtxImpl {
 			lazy_members: self.lazy_members,
-			sys: self.sys.clone(),
 			basepath: self.basepath,
 			path: self.path.push(seg),
 		}