diff --git a/src/lexer.rs b/src/lexer.rs
index 6fb66cb..e35d931 100644
--- a/src/lexer.rs
+++ b/src/lexer.rs
@@ -4,7 +4,7 @@ use std::{fmt, iter::Peekable};
 pub struct Ident(String);
 impl fmt::Display for Ident {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
+        self.0.fmt(f)
     }
 }
 
@@ -66,13 +66,13 @@ pub enum Token {
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 pub enum Precedence {
     Min,
-    Equality,
-    Relational,
-    Logical,
+    Assign,
     AddSub,
     MulDiv,
     Pow,
-    Assign,
+    Logical,
+    Relational,
+    Equality,
 }
 #[derive(PartialEq, Eq)]
 pub enum Associativity {
diff --git a/src/main.rs b/src/main.rs
index f8058a9..4e517df 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,5 +9,5 @@ fn main() {
     let lexer = Lexer::new(script.chars());
     let mut parser = Parser::new(lexer.map(Result::unwrap));
     let block = parser.parse().unwrap();
-    println!("{block}");
+    println!("{block:?}");
 }
diff --git a/src/parser.rs b/src/parser.rs
index 5b7f020..7d88ad7 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,9 +1,6 @@
-use std::{
-    fmt::{self, Pointer},
-    iter::Peekable,
-};
+use std::iter::Peekable;
 
-use crate::lexer::{Associativity, Ident, LexError, Literal, Precedence, Token};
+use crate::lexer::{Associativity, LexError, Literal, Precedence, Token};
 
 #[derive(Debug)]
 pub enum Expr {
@@ -35,61 +32,11 @@ pub enum Expr {
     Divide(Box<Expr>, Box<Expr>),
     Exponent(Box<Expr>, Box<Expr>),
 }
-impl fmt::Display for Expr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Expr::Assignment(l, r) => write!(f, "({l} = {r})\n"),
-            Expr::Literal(l) => write!(f, "{l}"),
-            Expr::Call(l, r) => {
-                write!(f, "{l}(")?;
-                for e in r {
-                    write!(f, "{e}, ")?;
-                }
-                write!(f, ")")?;
-                Ok(())
-            }
-            Expr::Return(l) => {
-                write!(f, "return {l}")
-            }
-            Expr::Block(b) => {
-                write!(f, "{{\n")?;
-                for e in &b.exprs {
-                    write!(f, "\t{e}\n")?;
-                }
-                write!(f, "}}")?;
-                Ok(())
-            }
-            Expr::Negate(l) => write!(f, "(-{l})"),
-            Expr::Not(l) => write!(f, "(!{l})"),
-            Expr::EqualTo(l, r) => write!(f, "({l} == {r})"),
-            Expr::NotEqualTo(l, r) => write!(f, "({l} != {r})"),
-            Expr::And(l, r) => write!(f, "({l} && {r})"),
-            Expr::Or(l, r) => write!(f, "({l} !|| {r})"),
-            Expr::LessThan(l, r) => write!(f, "({l} < {r})"),
-            Expr::LessThanOrEqualTo(l, r) => write!(f, "({l} <= {r})"),
-            Expr::GreaterThan(l, r) => write!(f, "({l} > {r})"),
-            Expr::GreaterThanOrEqualTo(l, r) => write!(f, "({l} >= {r})"),
-            Expr::Add(l, r) => write!(f, "({l} + {r})"),
-            Expr::Subtract(l, r) => write!(f, "({l} - {r})"),
-            Expr::Multiply(l, r) => write!(f, "({l} * {r})"),
-            Expr::Divide(l, r) => write!(f, "({l} / {r})"),
-            Expr::Exponent(l, r) => write!(f, "({l} ^ {r})"),
-        }
-    }
-}
 
 #[derive(Debug, Default)]
 pub struct Block {
     exprs: Vec<Expr>,
 }
-impl fmt::Display for Block {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for e in &self.exprs {
-            e.fmt(f)?;
-        }
-        Ok(())
-    }
-}
 
 #[derive(Debug)]
 pub enum ParseError {