fn parse_rev_recursive(tokens: &mut std::iter::Peekable<std::slice::Iter<(Token, Span)>>) -> Expr {
    // .a.b
    // a..b
    // a.(b..a)
    // )a(
    // .....a

    match tokens.next().unwrap() {
        (Token::Operator, span) => {
            let expr = Box::new(parse_rev_recursive(tokens));
            Expr::Unop {
                expr, op: span.clone()
            }
        }
        (Token::Identifier, span) => {
            match tokens.peek() {
                Some((Token::Operator, op_span)) => {
                    tokens.next();
                    let rhs = Box::new(Expr::Ident(span.clone()));
                    let lhs = Box::new(parse_rev_recursive(tokens));
                    Expr::Binop {
                        rhs, op: op_span.clone(), lhs
                    }
                }
                Some((Token::ParenLeft, _)) | None => Expr::Ident(span.clone()),
                _ => panic!("bruh moment"),
            }
        }
        (Token::ParenRight, span) => {
            let expr = Box::new(parse_rev_recursive(tokens));
            let (l_token, l_span) = tokens.next().unwrap();
            assert_eq!(*l_token, Token::ParenLeft);
            Expr::Paren {
                r: span.clone(), expr, l: l_span.clone(),
            }
        }
        _ => panic!("wtf"),
    }
}

fn parse_expr_reverse(tokens: &[(Token, Span)]) -> Option<Expr> {
    if tokens.is_empty() {
        return None;
    }
    let mut tokens = tokens.iter().peekable();

    Some(parse_rev_recursive(&mut tokens))
}