fix "if" parsing

src/parser.rs

@@ -137,26 +137,23 @@ where
             // unary ops!! (prefix)
             t if t.prefix_precedence().is_some() => {
                 let prec = t.prefix_precedence().unwrap();
+                match t {
                     // parse function
-                if matches!(t, Token::Func) {
+                    Token::Func => {
                         // parse args
                         self.expect_next(TokenKind::ParenOpen)?;
-                    let args =
+                        let args = self
-                        self.parse_delimited_until(TokenKind::Comma, Some(TokenKind::ParenClose))?;
+                            .parse_delimited_until(TokenKind::Comma, Some(TokenKind::ParenClose))?;
                         self.eat();
-
                         // parse body
                         let body = self.parse_expr(prec, in_group)?;
-
                         // pack
                         Box::new(Expr::Func(args, body))
-                } else {
+                    }
-                    let rhs = self.parse_expr(prec, in_group)?;
+                    // parse if
-                    Box::new(match t {
-                        Token::Minus => Expr::Negate(rhs),
-                        Token::Not => Expr::Not(rhs),
-                        Token::Return => Expr::Return(rhs),
                     Token::If => {
+                        // parse the condition
+                        let cond = self.parse_expr(Precedence::Min, false)?;
                         // parse the true case
                         let true_case = self.parse_expr(prec, in_group)?;
                         // and maybe a false case
@@ -167,12 +164,22 @@ where
                             })
                             .transpose()?;
                         // pack
-                            Expr::If(rhs, true_case, false_case)
+                        Box::new(Expr::If(cond, true_case, false_case))
                     }
+
+                    // another op
+                    _ => {
+                        let rhs = self.parse_expr(prec, in_group)?;
+                        Box::new(match t {
+                            Token::Minus => Expr::Negate(rhs),
+                            Token::Not => Expr::Not(rhs),
+                            Token::Return => Expr::Return(rhs),
+
                             _ => unreachable!(),
                         })
                     }
                 }
+            }
 
             // unexpected token
             t => return Err(ParseError::UnexpectedToken(t)),