j/Doughlang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ast: fn main, structification

Browse Source 
parser: unified post/infix, context-full grammar
repl: modes
This commit is contained in:
John
2025-09-21 02:57:20 -04:00
parent 434fa225e7
commit 8640ec4261
4 changed files with 342 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
src/ast/macro_matcher.rs
View File

@@ -78,6 +78,60 @@ impl<M: Match<A> + Annotation, A: Annotation> Match<A> for Anno<M, A> {
}
}
impl<A: Annotation> Match<A> for Const<A> {
fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
let (Self(pat_pat, pat_expr), Self(expr_pat, expr_expr)) = (pat, expr);
Match::recurse(sub, pat_pat, expr_pat) && Match::recurse(sub, pat_expr, expr_expr)
}
fn apply(&mut self, sub: &Subst<A>) {
let Self(pat, expr) = self;
pat.apply(sub);
expr.apply(sub);
}
}
impl<A: Annotation> Match<A> for Fn<A> {
fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
let (Self(pat_id, pat_arg, pat_body), Self(expr_id, expr_arg, expr_body)) = (pat, expr);
pat_id == expr_id
&& Match::recurse(sub, pat_arg, expr_arg)
&& Match::recurse(sub, pat_body, expr_body)
}
fn apply(&mut self, sub: &Subst<A>) {
let Self(_, pat, body) = self;
pat.apply(sub);
body.apply(sub);
}
}
impl<A: Annotation> Match<A> for Let<A> {
fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
let (Self(pat_pat, pat_expr), Self(expr_pat, expr_expr)) = (pat, expr);
Match::recurse(sub, pat_pat, expr_pat) && Match::recurse(sub, pat_expr, expr_expr)
}
fn apply(&mut self, sub: &Subst<A>) {
let Self(pat, expr) = self;
pat.apply(sub);
expr.apply(sub);
}
}
impl<A: Annotation> Match<A> for crate::ast::Match<A> {
fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
let (Self(pat_expr, pat_arms), Self(expr_expr, expr_arms)) = (pat, expr);
Match::recurse(sub, pat_expr, expr_expr) && Match::recurse(sub, pat_arms, expr_arms)
}
fn apply(&mut self, sub: &Subst<A>) {
let Self(pat, expr) = self;
pat.apply(sub);
expr.apply(sub);
}
}
impl<A: Annotation> Match<A> for Expr<A> {
fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
match (pat, expr) {
@@ -87,25 +141,17 @@ impl<A: Annotation> Match<A> for Expr<A> {
(Expr::Id(_), _) => false,
(Expr::Lit(pat), Expr::Lit(expr)) => pat == expr,
(Expr::Lit(_), _) => false,
(Expr::Let(pat_pat, pat_expr), Expr::Let(expr_pat, expr_expr)) => {
Match::recurse(sub, pat_pat, expr_pat) && Match::recurse(sub, pat_expr, expr_expr)
}
(Expr::Let(pat), Expr::Let(expr)) => Match::recurse(sub, pat, expr),
(Expr::Let(..), _) => false,
(Expr::Const(pat_pat, pat_expr), Expr::Const(expr_pat, expr_expr)) => {
Match::recurse(sub, pat_pat, expr_pat) && Match::recurse(sub, pat_expr, expr_expr)
}
(Expr::Const(pat), Expr::Const(expr)) => Match::recurse(sub, pat, expr),
(Expr::Const(..), _) => false,
(Expr::Make(pat, pat_arms), Expr::Make(expr, expr_arms)) => {
Match::recurse(sub, pat, expr) && Match::recurse(sub, pat_arms, expr_arms)
}
(Expr::Make(..), _) => false,
(Expr::Match(pat, pat_arms), Expr::Match(expr, expr_arms)) => {
Match::recurse(sub, pat, expr) && Match::recurse(sub, pat_arms, expr_arms)
}
(Expr::Match(pat), Expr::Match(expr)) => Match::recurse(sub, pat, expr),
(Expr::Match(..), _) => false,
(Expr::Fn(pat_pats, pat_expr), Expr::Fn(expr_pats, expr_expr)) => {
Match::recurse(sub, pat_pats, expr_pats) && Match::recurse(sub, pat_expr, expr_expr)
}
(Expr::Fn(pat), Expr::Fn(expr)) => Match::recurse(sub, pat, expr),
(Expr::Fn(..), _) => false,
(Expr::Op(pat_op, pat_exprs), Expr::Op(expr_op, expr_exprs)) => {
Match::recurse(sub, pat_op, expr_op) && Match::recurse(sub, pat_exprs, expr_exprs)
@@ -122,24 +168,20 @@ impl<A: Annotation> Match<A> for Expr<A> {
}
}
Expr::Id(_) | Expr::Lit(_) => {}
Expr::Let(pat, expr) => {
pat.apply(sub);
Expr::Let(expr) => {
expr.apply(sub);
}
Expr::Const(pat, expr) => {
pat.apply(sub);
Expr::Const(expr) => {
expr.apply(sub);
}
Expr::Make(expr, make_arms) => {
expr.apply(sub);
make_arms.apply(sub);
}
Expr::Match(expr, match_arms) => {
Expr::Match(expr) => {
expr.apply(sub);
match_arms.apply(sub);
}
Expr::Fn(pats, expr) => {
pats.apply(sub);
Expr::Fn(expr) => {
expr.apply(sub);
}
Expr::Op(op, exprs) => {