Method parse_pattern

leanr-syntax/src/parser.rs:595–648

Parse a pattern

(&mut self)

    /// Parse a pattern
    fn parse_pattern(&mut self) -> crate::Result<Pattern> {
        let token = self.current();

        match &token.kind {
            TokenKind::Underscore => {
                let span = token.span;
                self.advance();
                Ok(Pattern::Wildcard { span })
            }

            TokenKind::Number(n) => {
                let n = n.clone();
                let span = token.span;
                self.advance();
                let num = n.parse::<u64>().map_err(|_| {
                    ParseError::new(span, "Invalid number in pattern".to_string())
                })?;
                Ok(Pattern::Lit {
                    span,
                    lit: LitKind::Nat(num),
                })
            }

            TokenKind::Ident(name) => {
                let span = token.span;
                let ident = Ident::new(name.clone(), span);
                self.advance();

                // Check if this is a constructor with args
                let mut args = Vec::new();
                while !self.is_eof() && self.is_pattern_start() && !self.check(&TokenKind::FatArrow) {
                    args.push(self.parse_pattern()?);
                }

                if args.is_empty() {
                    // Simple variable
                    Ok(Pattern::Var { span, name: ident })
                } else {
                    // Constructor pattern
                    let end = args.last().unwrap().span();
                    Ok(Pattern::Constructor {
                        span: span.to(end),
                        name: ident,
                        args,
                    })
                }
            }

            _ => Err(ParseError::new(
                token.span,
                format!("Expected pattern, found {:?}", token.kind),
            )),
        }
    }

    /// Parse an identifier
    fn parse_ident(&mut self) -> crate::Result<Ident> {