conlang: PATTERN MATCHING AND DESTRUCTURED BINDINGS WOOOOO

- Integrate the Match and Pattern nodes into the AST
  - TODO: `let x: T` is ambiguous with `let x: {}`. Currently the latter takes precedence in the parser.

- Implement pattern matching through unification in the interpreter.
  - It's not fast, but it works!

- Refactor destructuring assignments to use the new pattern functionality

compiler/cl-ast/src/ast_visitor/fold.rs

@@ -240,7 +240,7 @@ pub trait Fold {
         let Let { mutable, name, ty, init } = l;
         Let {
             mutable: self.fold_mutability(mutable),
-            name: self.fold_sym(name),
+            name: self.fold_pattern(name),
             ty: ty.map(|t| Box::new(self.fold_ty(*t))),
             init: init.map(|e| Box::new(self.fold_expr(*e))),
         }
@@ -572,6 +572,7 @@ pub fn or_fold_expr_kind<F: Fold + ?Sized>(folder: &mut F, kind: ExprKind) -> Ex
         ExprKind::Empty => ExprKind::Empty,
         ExprKind::Quote(q) => ExprKind::Quote(q), // quoted expressions are left unmodified
         ExprKind::Let(l) => ExprKind::Let(folder.fold_let(l)),
+        ExprKind::Match(m) => ExprKind::Match(folder.fold_match(m)),
         ExprKind::Assign(a) => ExprKind::Assign(folder.fold_assign(a)),
         ExprKind::Modify(m) => ExprKind::Modify(folder.fold_modify(m)),
         ExprKind::Binary(b) => ExprKind::Binary(folder.fold_binary(b)),

compiler/cl-ast/src/ast_visitor/visit.rs

@@ -203,7 +203,7 @@ pub trait Visit<'a>: Sized {
     fn visit_let(&mut self, l: &'a Let) {
         let Let { mutable, name, ty, init } = l;
         self.visit_mutability(mutable);
-        self.visit_sym(name);
+        self.visit_pattern(name);
         if let Some(ty) = ty {
             self.visit_ty(ty);
         }
@@ -492,6 +492,7 @@ pub fn or_visit_expr_kind<'a, V: Visit<'a>>(visitor: &mut V, e: &'a ExprKind) {
         ExprKind::Empty => {}
         ExprKind::Quote(_q) => {} // Quoted expressions are left unvisited
         ExprKind::Let(l) => visitor.visit_let(l),
+        ExprKind::Match(m) => visitor.visit_match(m),
         ExprKind::Assign(a) => visitor.visit_assign(a),
         ExprKind::Modify(m) => visitor.visit_modify(m),
         ExprKind::Binary(b) => visitor.visit_binary(b),