Method parse_lambda

scribe-parser/src/parser/expressions.rs:381–457

(&mut self)

        cursor.advance();
        if cursor.peek() != TokenKind::Gt {
            loop {
                match Self::parse_type_impl(self.bump.clone(), &mut cursor, &mut pending) {
                    Ok(arg) => arg,
                    Err(_) => return false,
                };
                if !cursor.consume(TokenKind::Comma) {
                    break;
                }
            }
        } else {
            todo!("Handle error when trying to call like `hello<>()` ...")
        }
        if !Self::try_consume_close_angle(&mut cursor, &mut pending) {
            return false;
        }
        matches!(
            cursor.peek(),
            TokenKind::LParen | TokenKind::LBrace | TokenKind::Dot | TokenKind::ColonColon
        )
    }

    fn parse_prefix(&mut self) -> Result<Expr<'a, 'bump>, DiagnosticError<'a>> {
        let tok = self.cursor.peek_token();

        match tok.kind {
            TokenKind::If => self.parse_if_expr(),
            TokenKind::Match => self.parse_match_expr(),
            TokenKind::Unsafe => {
                self.cursor.advance();
                let block = self.parse_block()?;
                Ok(Expr::UnsafeBlock(self.bump.alloc_value_immutable(
                    UnsafeBlock {
                        block: self.bump.alloc_value_immutable(block),
                        span: tok.span,
                    },
                )))
            }

            TokenKind::Hexadecimal => {
                self.cursor.advance();
                let text = tok.text.unwrap_or_default();
                let value = Self::parse_radix_literal(text.as_str(), 2, 16);
                Ok(Expr::Number {
                    value,
                    span: tok.span,
                })
            }
            TokenKind::Octal => {
                self.cursor.advance();
                let text = tok.text.unwrap_or_default();
                let value = Self::parse_radix_literal(text.as_str(), 2, 8);
                Ok(Expr::Number {
                    value,
                    span: tok.span,
                })
            }
            TokenKind::Binary => {
                self.cursor.advance();