conlang: Unify binding operations!

This breaks out the pattern matching/unification algorithm from cl-interpret/interpret.rs to cl-interpret/pattern.rs

TODO: pattern destructuring in const, static :^)

compiler/cl-ast/src/ast.rs

@@ -153,7 +153,7 @@ pub struct Function {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Param {
     pub mutability: Mutability,
-    pub name: Sym,
+    pub bind: Pattern,
 }
 
 /// A user-defined product type

compiler/cl-ast/src/ast_impl.rs

@@ -194,8 +194,8 @@ mod display {
 
     impl Display for Param {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            let Self { mutability, name } = self;
+            let Self { mutability, bind } = self;
-            write!(f, "{mutability}{name}")
+            write!(f, "{mutability}{bind}")
         }
     }
 
@@ -474,11 +474,11 @@ mod display {
                 Pattern::Tuple(patterns) => separate(patterns, ", ")(f.delimit(INLINE_PARENS)),
                 Pattern::Array(patterns) => separate(patterns, ", ")(f.delimit(INLINE_SQUARE)),
                 Pattern::Struct(path, items) => {
-                    write!(f, "{path}: ")?;
+                    write!(f, "{path} ")?;
-                    let f = &mut f.delimit(BRACES);
+                    let f = &mut f.delimit(INLINE_BRACES);
                     for (idx, (name, item)) in items.iter().enumerate() {
                         if idx != 0 {
-                            f.write_str(",\n")?;
+                            f.write_str(", ")?;
                         }
                         write!(f, "{name}")?;
                         if let Some(pattern) = item {
@@ -639,7 +639,7 @@ mod display {
     impl Display for Structor {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let Self { to, init } = self;
-            write!(f, "{to}: ")?;
+            write!(f, "{to} ")?;
             separate(init, ", ")(f.delimit(INLINE_BRACES))
         }
     }

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

@@ -111,8 +111,8 @@ pub trait Fold {
         }
     }
     fn fold_param(&mut self, p: Param) -> Param {
-        let Param { mutability, name } = p;
+        let Param { mutability, bind } = p;
-        Param { mutability: self.fold_mutability(mutability), name: self.fold_sym(name) }
+        Param { mutability: self.fold_mutability(mutability), bind: self.fold_pattern(bind) }
     }
     fn fold_struct(&mut self, s: Struct) -> Struct {
         let Struct { name, kind } = s;

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

@@ -89,9 +89,9 @@ pub trait Visit<'a>: Sized {
         }
     }
     fn visit_param(&mut self, p: &'a Param) {
-        let Param { mutability, name } = p;
+        let Param { mutability, bind } = p;
         self.visit_mutability(mutability);
-        self.visit_sym(name);
+        self.visit_pattern(bind);
     }
     fn visit_struct(&mut self, s: &'a Struct) {
         let Struct { name, kind } = s;

compiler/cl-interpret/src/convalue.rs

@@ -319,7 +319,7 @@ impl std::fmt::Display for ConValue {
                 let (name, map) = parts.as_ref();
                 use std::fmt::Write;
                 if !name.is_empty() {
-                    write!(f, "{name}: ")?;
+                    write!(f, "{name} ")?;
                 }
                 let mut f = f.delimit_with("{", "\n}");
                 for (k, v) in map.iter() {

compiler/cl-interpret/src/function.rs

@@ -2,7 +2,7 @@
 
 use collect_upvars::collect_upvars;
 
-use super::{Callable, ConValue, Environment, Error, IResult, Interpret};
+use super::{pattern, Callable, ConValue, Environment, Error, IResult, Interpret};
 use cl_ast::{Function as FnDecl, Param, Sym};
 use std::{
     cell::{Ref, RefCell},
@@ -70,8 +70,10 @@ impl Callable for Function {
 
         // TODO: completely refactor data storage
         let mut frame = env.frame("fn args");
-        for (Param { mutability: _, name }, value) in bind.iter().zip(args) {
+        for (Param { mutability: _, bind }, value) in bind.iter().zip(args) {
-            frame.insert(*name, Some(value.clone()));
+            for (name, value) in pattern::substitution(bind, value.clone())? {
+                frame.insert(*name, Some(value));
+            }
         }
         let res = body.interpret(&mut frame);
         drop(frame);

compiler/cl-interpret/src/function/collect_upvars.rs

@@ -67,8 +67,8 @@ impl<'a> Visit<'a> for CollectUpvars<'_> {
     fn visit_function(&mut self, f: &'a cl_ast::Function) {
         let Function { name: _, sign: _, bind, body } = f;
         // parameters can never be upvars
-        for Param { mutability: _, name } in bind {
+        for Param { mutability: _, bind } in bind {
-            self.bind_name(name);
+            self.visit_pattern(bind);
         }
         if let Some(body) = body {
             self.visit_expr(body);

compiler/cl-interpret/src/interpret.rs

@@ -139,7 +139,7 @@ impl Interpret for Struct {
                         .enumerate()
                         .map(|(idx, _)| Param {
                             mutability: Mutability::Not,
-                            name: idx.to_string().into(),
+                            bind: Pattern::Name(idx.to_string().into()),
                         })
                         .collect(),
                     body: None,
@@ -300,12 +300,12 @@ impl Interpret for Let {
         let Let { mutable: _, name, ty: _, init } = self;
         match init.as_ref().map(|i| i.interpret(env)).transpose()? {
             Some(value) => {
-                for (name, value) in assignment::pattern_substitution(name, value)? {
+                for (name, value) in pattern::substitution(name, value)? {
                     env.insert(*name, Some(value));
                 }
             }
             None => {
-                for name in assignment::pattern_variables(name) {
+                for name in pattern::variables(name) {
                     env.insert(*name, None);
                 }
             }
@@ -319,7 +319,7 @@ impl Interpret for Match {
         let Self { scrutinee, arms } = self;
         let scrutinee = scrutinee.interpret(env)?;
         for MatchArm(pat, expr) in arms {
-            if let Ok(substitution) = assignment::pattern_substitution(pat, scrutinee.clone()) {
+            if let Ok(substitution) = pattern::substitution(pat, scrutinee.clone()) {
                 let mut env = env.frame("match");
                 for (name, value) in substitution {
                     env.insert(*name, Some(value));
@@ -337,136 +337,11 @@ mod assignment {
     use std::collections::HashMap;
     type Namespace = HashMap<Sym, Option<ConValue>>;
 
-    /// Gets the path variables in the given Pattern
-    pub fn pattern_variables(pat: &Pattern) -> Vec<&Sym> {
-        fn patvars<'p>(set: &mut Vec<&'p Sym>, pat: &'p Pattern) {
-            match pat {
-                Pattern::Name(name) if &**name == "_" => {}
-                Pattern::Name(name) => set.push(name),
-                Pattern::Literal(_) => {}
-                Pattern::Ref(_, pattern) => patvars(set, pattern),
-                Pattern::Tuple(patterns) | Pattern::Array(patterns) => {
-                    patterns.iter().for_each(|pat| patvars(set, pat))
-                }
-                Pattern::Struct(_path, items) => {
-                    items.iter().for_each(|(name, pat)| match pat {
-                        Some(pat) => patvars(set, pat),
-                        None => set.push(name),
-                    });
-                }
-                Pattern::TupleStruct(_path, items) => {
-                    items.iter().for_each(|pat| patvars(set, pat));
-                }
-            }
-        }
-        let mut set = Vec::new();
-        patvars(&mut set, pat);
-        set
-    }
-
-    /// Appends a substitution to the provided table
-    pub fn append_sub<'pat>(
-        sub: &mut HashMap<&'pat Sym, ConValue>,
-        pat: &'pat Pattern,
-        value: ConValue,
-    ) -> IResult<()> {
-        match (pat, value) {
-            (Pattern::Array(patterns), ConValue::Array(values))
-            | (Pattern::Tuple(patterns), ConValue::Tuple(values)) => {
-                if patterns.len() != values.len() {
-                    Err(Error::ArgNumber { want: patterns.len(), got: values.len() })?
-                }
-                for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) {
-                    append_sub(sub, pat, value)?;
-                }
-                Ok(())
-            }
-            (Pattern::Tuple(patterns), ConValue::Empty) if patterns.is_empty() => Ok(()),
-
-            (Pattern::Literal(Literal::Bool(a)), ConValue::Bool(b)) => {
-                (*a == b).then_some(()).ok_or(Error::NotAssignable)
-            }
-            (Pattern::Literal(Literal::Char(a)), ConValue::Char(b)) => {
-                (*a == b).then_some(()).ok_or(Error::NotAssignable)
-            }
-            (Pattern::Literal(Literal::Float(a)), ConValue::Float(b)) => (f64::from_bits(*a) == b)
-                .then_some(())
-                .ok_or(Error::NotAssignable),
-            (Pattern::Literal(Literal::Int(a)), ConValue::Int(b)) => {
-                (b == *a as _).then_some(()).ok_or(Error::NotAssignable)
-            }
-            (Pattern::Literal(Literal::String(a)), ConValue::String(b)) => {
-                (*a == *b).then_some(()).ok_or(Error::NotAssignable)
-            }
-            (Pattern::Literal(_), _) => Err(Error::NotAssignable),
-
-            (Pattern::Name(name), _) if "_".eq(&**name) => Ok(()),
-            (Pattern::Name(name), value) => {
-                sub.insert(name, value);
-                Ok(())
-            }
-
-            (Pattern::Ref(_, pat), ConValue::Ref(r)) => {
-                append_sub(sub, pat, Rc::unwrap_or_clone(r))
-            }
-
-            (Pattern::Struct(path, patterns), ConValue::Struct(parts)) => {
-                let (name, mut values) = *parts;
-                if !path.ends_with(&name) {
-                    Err(Error::TypeError)?
-                }
-                if patterns.len() != values.len() {
-                    return Err(Error::ArgNumber { want: patterns.len(), got: values.len() });
-                }
-                for (name, pat) in patterns {
-                    let value = values.remove(name).ok_or(Error::TypeError)?;
-                    match pat {
-                        Some(pat) => append_sub(sub, pat, value)?,
-                        None => {
-                            sub.insert(name, value);
-                        }
-                    }
-                }
-                Ok(())
-            }
-
-            (Pattern::TupleStruct(path, patterns), ConValue::TupleStruct(parts)) => {
-                let (name, values) = *parts;
-                if !path.ends_with(&name) {
-                    Err(Error::TypeError)?
-                }
-                if patterns.len() != values.len() {
-                    Err(Error::ArgNumber { want: patterns.len(), got: values.len() })?
-                }
-                for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) {
-                    append_sub(sub, pat, value)?;
-                }
-                Ok(())
-            }
-
-            (pat, value) => {
-                eprintln!("Could not match pattern `{pat}` with value `{value}`!");
-                Err(Error::NotAssignable)
-            }
-        }
-    }
-
-    /// Constructs a substitution from a pattern and a value
-    pub fn pattern_substitution(
-        pat: &Pattern,
-        value: ConValue,
-    ) -> IResult<HashMap<&Sym, ConValue>> {
-        let mut sub = HashMap::new();
-        append_sub(&mut sub, pat, value)?;
-        Ok(sub)
-    }
-
     pub(super) fn pat_assign(env: &mut Environment, pat: &Pattern, value: ConValue) -> IResult<()> {
-        let mut substitution = HashMap::new();
+        for (name, value) in
-        append_sub(&mut substitution, pat, value)
+            pattern::substitution(pat, value).map_err(|_| Error::PatFailed(pat.clone().into()))?
-            .map_err(|_| Error::PatFailed(pat.clone().into()))?;
+        {
-        for (path, value) in substitution {
+            *env.get_mut(*name)? = Some(value);
-            env.insert(*path, Some(value));
         }
         Ok(())
     }
@@ -478,6 +353,7 @@ mod assignment {
         match pat {
             ExprKind::Member(member) => *addrof_member(env, member)? = value,
             ExprKind::Index(index) => *addrof_index(env, index)? = value,
+            ExprKind::Path(path) => *addrof_path(env, &path.parts)? = Some(value),
             _ => Err(Error::NotAssignable)?,
         }
         Ok(())
@@ -978,7 +854,7 @@ impl Interpret for If {
 }
 impl Interpret for For {
     fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
-        let Self { bind: name, cond, pass, fail } = self;
+        let Self { bind, cond, pass, fail } = self;
         let cond = cond.interpret(env)?;
         // TODO: A better iterator model
         let mut bounds: Box<dyn Iterator<Item = ConValue>> = match &cond {
@@ -990,9 +866,8 @@ impl Interpret for For {
         };
         loop {
             let mut env = env.frame("loop variable");
-            if let Some(loop_var) = bounds.next() {
+            if let Some(value) = bounds.next() {
-                let subs = assignment::pattern_substitution(name, loop_var)?;
+                for (name, value) in pattern::substitution(bind, value)? {
-                for (name, value) in subs {
                     env.insert(*name, Some(value));
                 }
                 match pass.interpret(&mut env) {

compiler/cl-interpret/src/lib.rs

@@ -25,6 +25,8 @@ pub mod function;
 
 pub mod builtin;
 
+pub mod pattern;
+
 pub mod env;
 
 pub mod error;

compiler/cl-interpret/src/pattern.rs

@@ -0,0 +1,130 @@
+//! Unification algorithm for cl-ast patterns and ConValues
+//!
+//! [`variables()`] returns a flat list of symbols that are bound by a given pattern
+//! [`substitution()`] unifies a ConValue with a pattern, and produces a list of bound names
+
+use crate::{
+    convalue::ConValue,
+    error::{Error, IResult},
+};
+use cl_ast::{Literal, Pattern, Sym};
+use std::{collections::HashMap, rc::Rc};
+
+/// Gets the path variables in the given Pattern
+pub fn variables(pat: &Pattern) -> Vec<&Sym> {
+    fn patvars<'p>(set: &mut Vec<&'p Sym>, pat: &'p Pattern) {
+        match pat {
+            Pattern::Name(name) if &**name == "_" => {}
+            Pattern::Name(name) => set.push(name),
+            Pattern::Literal(_) => {}
+            Pattern::Ref(_, pattern) => patvars(set, pattern),
+            Pattern::Tuple(patterns) | Pattern::Array(patterns) => {
+                patterns.iter().for_each(|pat| patvars(set, pat))
+            }
+            Pattern::Struct(_path, items) => {
+                items.iter().for_each(|(name, pat)| match pat {
+                    Some(pat) => patvars(set, pat),
+                    None => set.push(name),
+                });
+            }
+            Pattern::TupleStruct(_path, items) => {
+                items.iter().for_each(|pat| patvars(set, pat));
+            }
+        }
+    }
+    let mut set = Vec::new();
+    patvars(&mut set, pat);
+    set
+}
+
+/// Appends a substitution to the provided table
+pub fn append_sub<'pat>(
+    sub: &mut HashMap<&'pat Sym, ConValue>,
+    pat: &'pat Pattern,
+    value: ConValue,
+) -> IResult<()> {
+    match (pat, value) {
+        (Pattern::Array(patterns), ConValue::Array(values))
+        | (Pattern::Tuple(patterns), ConValue::Tuple(values)) => {
+            if patterns.len() != values.len() {
+                Err(Error::ArgNumber { want: patterns.len(), got: values.len() })?
+            }
+            for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) {
+                append_sub(sub, pat, value)?;
+            }
+            Ok(())
+        }
+        (Pattern::Tuple(patterns), ConValue::Empty) if patterns.is_empty() => Ok(()),
+
+        (Pattern::Literal(Literal::Bool(a)), ConValue::Bool(b)) => {
+            (*a == b).then_some(()).ok_or(Error::NotAssignable)
+        }
+        (Pattern::Literal(Literal::Char(a)), ConValue::Char(b)) => {
+            (*a == b).then_some(()).ok_or(Error::NotAssignable)
+        }
+        (Pattern::Literal(Literal::Float(a)), ConValue::Float(b)) => (f64::from_bits(*a) == b)
+            .then_some(())
+            .ok_or(Error::NotAssignable),
+        (Pattern::Literal(Literal::Int(a)), ConValue::Int(b)) => {
+            (b == *a as _).then_some(()).ok_or(Error::NotAssignable)
+        }
+        (Pattern::Literal(Literal::String(a)), ConValue::String(b)) => {
+            (*a == *b).then_some(()).ok_or(Error::NotAssignable)
+        }
+        (Pattern::Literal(_), _) => Err(Error::NotAssignable),
+
+        (Pattern::Name(name), _) if "_".eq(&**name) => Ok(()),
+        (Pattern::Name(name), value) => {
+            sub.insert(name, value);
+            Ok(())
+        }
+
+        (Pattern::Ref(_, pat), ConValue::Ref(r)) => append_sub(sub, pat, Rc::unwrap_or_clone(r)),
+
+        (Pattern::Struct(path, patterns), ConValue::Struct(parts)) => {
+            let (name, mut values) = *parts;
+            if !path.ends_with(&name) {
+                Err(Error::TypeError)?
+            }
+            if patterns.len() != values.len() {
+                return Err(Error::ArgNumber { want: patterns.len(), got: values.len() });
+            }
+            for (name, pat) in patterns {
+                let value = values.remove(name).ok_or(Error::TypeError)?;
+                match pat {
+                    Some(pat) => append_sub(sub, pat, value)?,
+                    None => {
+                        sub.insert(name, value);
+                    }
+                }
+            }
+            Ok(())
+        }
+
+        (Pattern::TupleStruct(path, patterns), ConValue::TupleStruct(parts)) => {
+            let (name, values) = *parts;
+            if !path.ends_with(&name) {
+                Err(Error::TypeError)?
+            }
+            if patterns.len() != values.len() {
+                Err(Error::ArgNumber { want: patterns.len(), got: values.len() })?
+            }
+            for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) {
+                append_sub(sub, pat, value)?;
+            }
+            Ok(())
+        }
+
+        (pat, value) => {
+            eprintln!("Could not match pattern `{pat}` with value `{value}`!");
+            Err(Error::NotAssignable)
+        }
+    }
+}
+
+/// Constructs a substitution from a pattern and a value
+pub fn substitution(pat: &Pattern, value: ConValue) -> IResult<HashMap<&Sym, ConValue>> {
+    let mut sub = HashMap::new();
+    append_sub(&mut sub, pat, value)?;
+    Ok(sub)
+}

compiler/cl-parser/src/error.rs

@@ -1,5 +1,6 @@
 use super::*;
 
+use cl_ast::ExprKind;
 use cl_lexer::error::{Error as LexError, Reason};
 use std::fmt::Display;
 pub type PResult<T> = Result<T, Error>;
@@ -29,6 +30,7 @@ pub enum ErrorKind {
     ExpectedParsing {
         want: Parsing,
     },
+    InvalidPattern(Box<ExprKind>),
     /// Indicates unfinished code
     Todo(&'static str),
 }
@@ -148,6 +150,7 @@ impl Display for ErrorKind {
             ErrorKind::Unexpected(t) => write!(f, "Encountered unexpected token `{t}`"),
             ErrorKind::ExpectedToken { want: e, got: g } => write!(f, "Expected `{e}`, got `{g}`"),
             ErrorKind::ExpectedParsing { want } => write!(f, "Expected {want}"),
+            ErrorKind::InvalidPattern(got) => write!(f, "Got invalid `{got}`"),
             ErrorKind::Todo(unfinished) => write!(f, "TODO: {unfinished}"),
         }
     }

compiler/cl-parser/src/parser.rs

@@ -494,7 +494,7 @@ impl Parse<'_> for TypedParam {
     /// Parses a single function [parameter](Param)
     fn parse(p: &mut Parser) -> PResult<(Param, TyKind)> {
         Ok((
-            Param { mutability: Mutability::parse(p)?, name: Sym::parse(p)? },
+            Param { mutability: Mutability::parse(p)?, bind: Pattern::parse(p)? },
             {
                 p.match_type(TokenKind::Colon, Parsing::Param)?;
                 TyKind::parse(p)?
@@ -1006,13 +1006,20 @@ impl Parse<'_> for Block {
     }
 }
 
+/// Conditions (which precede curly-braced blocks) get special treatment
+fn condition(p: &mut Parser) -> PResult<Expr> {
+    let start = p.loc();
+    let kind = prec::exprkind(p, prec::Precedence::Condition.level())?;
+    Ok(Expr { kind, extents: Span(start, p.loc()) })
+}
+
 impl Parse<'_> for While {
     /// [While] = `while` [Expr] [Block] [Else]?
     #[rustfmt::skip]
     fn parse(p: &mut Parser) -> PResult<While> {
         p.match_type(TokenKind::While, Parsing::While)?;
         Ok(While {
-            cond: Expr::parse(p)?.into(),
+            cond: condition(p)?.into(),
             pass: Block::parse(p)?.into(),
             fail: Else::parse(p)?
         })
@@ -1025,7 +1032,7 @@ impl Parse<'_> for If {
     fn parse(p: &mut Parser) -> PResult<If> {
         p.match_type(TokenKind::If, Parsing::If)?;
         Ok(If {
-            cond: Expr::parse(p)?.into(),
+            cond: condition(p)?.into(),
             pass: Block::parse(p)?.into(),
             fail: Else::parse(p)?,
         })
@@ -1033,7 +1040,7 @@ impl Parse<'_> for If {
 }
 
 impl Parse<'_> for For {
-    /// [For]: `for` Pattern (TODO) `in` [Expr] [Block] [Else]?
+    /// [For]: `for` [Pattern] `in` [Expr] [Block] [Else]?
     #[rustfmt::skip]
     fn parse(p: &mut Parser) -> PResult<For> {
         p.match_type(TokenKind::For, Parsing::For)?;
@@ -1041,7 +1048,7 @@ impl Parse<'_> for For {
         p.match_type(TokenKind::In, Parsing::For)?;
         Ok(For {
             bind,
-            cond: Expr::parse(p)?.into(),
+            cond: condition(p)?.into(),
             pass: Block::parse(p)?.into(),
             fail: Else::parse(p)?,
         })
@@ -1081,8 +1088,7 @@ impl Parse<'_> for Return {
 impl Parse<'_> for Pattern {
     fn parse(p: &mut Parser<'_>) -> PResult<Self> {
         let value = prec::exprkind(p, prec::Precedence::Pattern.level())?;
-        Pattern::try_from(value)
+        Pattern::try_from(value).map_err(|e| p.error(InvalidPattern(e.into()), Parsing::Pattern))
-            .map_err(|_| p.error(ExpectedParsing { want: Parsing::Pattern }, Parsing::Pattern))
     }
 }
 

compiler/cl-parser/src/parser/prec.rs

@@ -44,7 +44,9 @@ pub fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
         Some(match op {
             TokenKind::LBrack => Precedence::Index,
             TokenKind::LParen => Precedence::Call,
+            TokenKind::LCurly => Precedence::Structor,
             TokenKind::Dot => Precedence::Member,
+            TokenKind::As => Precedence::Cast,
             _ => None?,
         })
     }
@@ -55,25 +57,36 @@ pub fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
             if before < power {
                 break;
             }
-            p.consume_peeked();
 
             head = match op {
                 TokenKind::LBrack => {
+                    p.consume_peeked();
                     let indices =
                         sep(Expr::parse, TokenKind::Comma, TokenKind::RBrack, parsing)(p)?;
                     p.match_type(TokenKind::RBrack, parsing)?;
                     ExprKind::Index(Index { head: head.into(), indices })
                 }
                 TokenKind::LParen => {
+                    p.consume_peeked();
                     let exprs = sep(Expr::parse, TokenKind::Comma, TokenKind::RParen, parsing)(p)?;
                     p.match_type(TokenKind::RParen, parsing)?;
                     Binary { kind: BinaryKind::Call, parts: (head, Tuple { exprs }.into()).into() }
                         .into()
                 }
+                TokenKind::LCurly => match head {
+                    ExprKind::Path(path) => ExprKind::Structor(structor_body(p, path)?),
+                    _ => break,
+                },
                 TokenKind::Dot => {
+                    p.consume_peeked();
                     let kind = MemberKind::parse(p)?;
                     Member { head: Box::new(head), kind }.into()
                 }
+                TokenKind::As => {
+                    p.consume_peeked();
+                    let ty = Ty::parse(p)?;
+                    Cast { head: head.into(), ty }.into()
+                }
                 _ => Err(p.error(Unexpected(op), parsing))?,
             };
             continue;
@@ -217,11 +230,7 @@ fn exprkind_group(p: &mut Parser) -> PResult<ExprKind> {
 
 /// Parses an expression beginning with a [Path] (i.e. [Path] or [Structor])
 fn exprkind_pathlike(p: &mut Parser) -> PResult<ExprKind> {
-    let head = Path::parse(p)?;
+    Path::parse(p).map(Into::into)
-    Ok(match p.match_type(TokenKind::Colon, Parsing::Path) {
-        Ok(_) => ExprKind::Structor(structor_body(p, head)?),
-        Err(_) => ExprKind::Path(head),
-    })
 }
 
 /// [Structor]Body = `{` ([Fielder] `,`)* [Fielder]? `}`
@@ -244,6 +253,9 @@ fn structor_body(p: &mut Parser, to: Path) -> PResult<Structor> {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum Precedence {
     Assign,
+    Pattern,   // A pattern can contain a structor
+    Structor,  // A structor is never a valid conditional
+    Condition, // Anything that syntactically needs a block following it
     Logic,
     Compare,
     Range,
@@ -255,7 +267,6 @@ pub enum Precedence {
     Index,
     Cast,
     Member, // left-associative
-    Pattern,
     Call,
 }
 
@@ -284,7 +295,9 @@ impl Precedence {
 
     pub fn postfix(self) -> Option<(u8, ())> {
         match self {
-            Self::Index | Self::Call | Self::Member => Some((self.level(), ())),
+            Self::Structor | Self::Index | Self::Call | Self::Member | Self::Cast => {
+                Some((self.level(), ()))
+            }
             _ => None,
         }
     }

compiler/cl-repl/examples/yaml.rs

@@ -643,8 +643,8 @@ pub mod yamlify {
     }
     impl Yamlify for Param {
         fn yaml(&self, y: &mut Yamler) {
-            let Self { mutability, name } = self;
+            let Self { mutability, bind } = self;
-            y.key("Param").yaml(mutability).pair("name", name);
+            y.key("Param").yaml(mutability).pair("pat", bind);
         }
     }
     impl Yamlify for Ty {