Various progress, doesnt compile

Added prelude, made lambdas a single-token prefix like NS, made progress on implementations, removed const line type

orchid-extension/src/parser.rs

@@ -4,12 +4,12 @@ use futures::FutureExt;
 use futures::future::{LocalBoxFuture, join_all};
 use itertools::Itertools;
 use orchid_api::ResolveNames;
-use orchid_base::error::OrcRes;
+use orchid_base::error::{OrcRes, Reporter};
 use orchid_base::id_store::IdStore;
-use orchid_base::interner::Tok;
+use orchid_base::interner::{Interner, Tok};
 use orchid_base::location::SrcRange;
 use orchid_base::name::Sym;
-use orchid_base::parse::{Comment, Snippet};
+use orchid_base::parse::{Comment, ParseCtx, Snippet};
 use orchid_base::reqnot::{ReqHandlish, Requester};
 use orchid_base::tree::ttv_into_api;
 
@@ -61,12 +61,19 @@ pub struct ParsCtx<'a> {
 	_parse: PhantomData<&'a mut ()>,
 	ctx: SysCtx,
 	module: Sym,
+	reporter: &'a Reporter,
 }
-impl ParsCtx<'_> {
-	pub(crate) fn new(ctx: SysCtx, module: Sym) -> Self { Self { _parse: PhantomData, ctx, module } }
+impl<'a> ParsCtx<'a> {
+	pub(crate) fn new(ctx: SysCtx, module: Sym, reporter: &'a Reporter) -> Self {
+		Self { _parse: PhantomData, ctx, module, reporter }
+	}
 	pub fn ctx(&self) -> &SysCtx { &self.ctx }
 	pub fn module(&self) -> Sym { self.module.clone() }
 }
+impl ParseCtx for ParsCtx<'_> {
+	fn i(&self) -> &Interner { self.ctx.i() }
+	fn reporter(&self) -> &Reporter { self.reporter }
+}
 
 type BoxConstCallback = Box<dyn FnOnce(ConstCtx) -> LocalBoxFuture<'static, GExpr>>;
 
@@ -94,8 +101,10 @@ impl ParsedLine {
 						ParsedMemKind::Const(cb) => api::ParsedMemberKind::Constant(api::ParsedConstId(
 							ctx.get_or_default::<ParsedConstCtxEntry>().consts.add(cb).id(),
 						)),
-						ParsedMemKind::Mod(plv) =>
-							api::ParsedMemberKind::Module(linev_into_api(plv, ctx, hand).boxed_local().await),
+						ParsedMemKind::Mod { lines, use_prelude } => api::ParsedMemberKind::Module {
+							lines: linev_into_api(lines, ctx, hand).boxed_local().await,
+							use_prelude,
+						},
 					},
 				}),
 				ParsedLineKind::Rec(tv) =>
@@ -119,20 +128,26 @@ pub enum ParsedLineKind {
 }
 
 pub struct ParsedMem {
-	name: Tok<String>,
-	exported: bool,
-	kind: ParsedMemKind,
+	pub name: Tok<String>,
+	pub exported: bool,
+	pub kind: ParsedMemKind,
 }
 
 pub enum ParsedMemKind {
 	Const(BoxConstCallback),
-	Mod(Vec<ParsedLine>),
+	Mod { lines: Vec<ParsedLine>, use_prelude: bool },
 }
 
 impl ParsedMemKind {
 	pub fn cnst<F: AsyncFnOnce(ConstCtx) -> GExpr + 'static>(f: F) -> Self {
 		Self::Const(Box::new(|ctx| Box::pin(f(ctx))))
 	}
+	pub fn module(lines: impl IntoIterator<Item = ParsedLine>) -> Self {
+		Self::Mod { lines: lines.into_iter().collect(), use_prelude: true }
+	}
+	pub fn clean_module(lines: impl IntoIterator<Item = ParsedLine>) -> Self {
+		Self::Mod { lines: lines.into_iter().collect(), use_prelude: false }
+	}
 }
 
 /* TODO: how the macro runner uses the multi-stage loader