First steps for the macro system

orchid-std/src/macros/let_line.rs

@@ -1,20 +1,17 @@
-use futures::future::LocalBoxFuture;
+use async_std::stream;
+use async_stream::stream;
+use futures::{FutureExt, StreamExt};
 use hashbrown::HashMap;
 use itertools::Itertools;
-use orchid_base::error::{OrcRes, mk_errv};
-use orchid_base::interner::Tok;
-use orchid_base::name::Sym;
-use orchid_base::parse::{Comment, ParseCtx, Parsed, expect_tok, token_errv, try_pop_no_fluff};
-use orchid_extension::gen_expr::GExpr;
-use orchid_extension::parser::{
-	ConstCtx, GenSnippet, ParsCtx, ParsedLine, ParsedLineKind, ParsedMem, ParsedMemKind, Parser,
+use orchid_base::error::OrcRes;
+use orchid_base::parse::{
+	Comment, ParseCtx, Parsed, Snippet, expect_tok, token_errv, try_pop_no_fluff,
+};
+use orchid_extension::parser::{
+	PSnippet, PTok, PTokTree, ParsCtx, ParsedLine, ParsedLineKind, ParsedMem, ParsedMemKind, Parser,
 };
-use substack::Substack;
 
-use crate::macros::mactree::{MacTok, MacTree, map_mactree, map_mactree_v};
-
-type ExprGenerator =
-	Box<dyn for<'a> FnOnce(ConstCtx, Substack<'a, Sym>) -> LocalBoxFuture<'a, GExpr>>;
+use crate::macros::mactree::{MacTok, MacTree, map_mactree_v};
 
 #[derive(Default)]
 pub struct LetLine;
@@ -24,7 +21,7 @@ impl Parser for LetLine {
 		ctx: ParsCtx<'a>,
 		exported: bool,
 		comments: Vec<Comment>,
-		line: GenSnippet<'a>,
+		line: PSnippet<'a>,
 	) -> OrcRes<Vec<ParsedLine>> {
 		let Parsed { output: name_tok, tail } = try_pop_no_fluff(&ctx, line).await?;
 		let Some(name) = name_tok.as_name() else {
@@ -34,19 +31,11 @@ impl Parser for LetLine {
 			return Err(err.await);
 		};
 		let Parsed { tail, .. } = expect_tok(&ctx, tail, ctx.i().i("=").await).await?;
-		fn parse_tokv(line: GenSnippet<'_>) -> Vec<MacTree> {
-			let first: MacTree = if let Some((idx, arg)) =
-				line.iter().enumerate().find_map(|(i, x)| Some((i, x.as_lambda()?)))
-			{
-			} else {
-			};
-			todo!()
-		}
 		let mut names = HashMap::new();
-		let aliased = parse_tokv(tail);
+		let aliased = parse_tokv(tail, &ctx).await;
 		map_mactree_v(&aliased, &mut false, &mut |tpl| {
 			if let MacTok::Name(n) = &*tpl.tok {
-				names.insert(n.clone(), n);
+				names.insert(n.clone(), n.clone());
 			}
 			None
 		});
@@ -56,14 +45,76 @@ impl Parser for LetLine {
 			kind: ParsedLineKind::Mem(ParsedMem {
 				exported,
 				name,
-				kind: ParsedMemKind::cnst(async |ctx| {
-					let mut names_str = ctx.names(names.keys());
-					while let Some(()) = names_str.next().await {
-						names[]
+				kind: ParsedMemKind::cnst(async move |ctx| {
+					let keys = names.keys().cloned().collect_vec();
+					let names_mut = &mut names;
+					stream! {
+						for await (canonical, local) in ctx.names(&keys).zip(stream::from_iter(&keys)) {
+							if let Some(name) = canonical {
+								*names_mut.get_mut(local).expect("Queried specifically the keys of this map") = name
+							}
+						}
 					}
-					todo!()
+					.collect::<()>()
+					.await;
+					let macro_input = map_mactree_v(&aliased, &mut false, &mut |tree| match &*tree.tok {
+						MacTok::Name(n) => names.get(n).map(|new_n| MacTok::Name(new_n.clone()).at(tree.pos())),
+						_ => None,
+					});
+					todo!("Run macros then convert this into an expr")
 				}),
 			}),
 		}])
 	}
 }
+
+async fn parse_tokv(line: PSnippet<'_>, ctx: &ParsCtx<'_>) -> Vec<MacTree> {
+	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 {
+			Some(arg) => all.push(MacTok::Lambda(arg, body).at(lambda.sr().pos())),
+			None => ctx.rep().report(
+				token_errv(ctx, arg, "Lambda argument fluff", |arg| {
+					format!("Lambda arguments must be a valid token, found meaningless fragment {arg}")
+				})
+				.await,
+			),
+		};
+		all
+	} else {
+		parse_tokv_no_lambdas(&line, ctx).await
+	}
+}
+
+async fn parse_tokv_no_lambdas(line: &[PTokTree], ctx: &ParsCtx<'_>) -> Vec<MacTree> {
+	stream::from_iter(line).filter_map(|tt| parse_tok(tt, ctx)).collect().await
+}
+
+async fn parse_tok(tree: &PTokTree, ctx: &ParsCtx<'_>) -> 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(ctx.module().suffix([n.clone()], ctx.i()).await),
+		PTok::NS(..) => match tree.as_multiname() {
+			Ok(mn) => MacTok::Name(mn.to_sym(ctx.i()).await),
+			Err(nested) => {
+				ctx.rep().report(
+					token_errv(ctx, 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;
+			},
+		},
+		PTok::Handle(expr) => MacTok::Value(expr.clone()),
+		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),
+	};
+	Some(tok.at(tree.sr().pos()))
+}