diff --git a/src/lex.rs b/src/lex.rs
index 1cedbd6..cf48fb1 100644
--- a/src/lex.rs
+++ b/src/lex.rs
@@ -86,13 +86,13 @@ pub enum TokenType<'code> {
     /// !=
     BangEqual,
     /// >
-    GreaterThan,
+    Greater,
     /// <
-    LessThan,
+    Less,
     /// >=
-    GreaterThanEqual,
+    GreaterEqual,
     /// <=
-    LessThanEqual,
+    LessEqual,
 }
 
 #[derive(Debug, Clone)]
@@ -204,18 +204,13 @@ impl<'code> Iterator for Lexer<'code> {
                 '>' => {
                     break self.maybe_next_char(
                         '=',
-                        TokenType::GreaterThanEqual,
-                        TokenType::GreaterThan,
+                        TokenType::GreaterEqual,
+                        TokenType::Greater,
                         start,
                     );
                 }
                 '<' => {
-                    break self.maybe_next_char(
-                        '=',
-                        TokenType::LessThanEqual,
-                        TokenType::LessThan,
-                        start,
-                    );
+                    break self.maybe_next_char('=', TokenType::LessEqual, TokenType::Less, start);
                 }
                 '"' => {
                     let mut buffer = String::new();
@@ -426,10 +421,7 @@ mod test {
 
     #[test]
     fn smiley_face() {
-        lex_test(
-            ">>.<<",
-            vec![GreaterThan, GreaterThan, Dot, LessThan, LessThan],
-        )
+        lex_test(">>.<<", vec![Greater, Greater, Dot, Less, Less])
     }
 
     #[test]
@@ -437,12 +429,12 @@ mod test {
         lex_test(
             ">= <= == < < >=",
             vec![
-                GreaterThanEqual,
-                LessThanEqual,
+                GreaterEqual,
+                LessEqual,
                 EqualEqual,
-                LessThan,
-                LessThan,
-                GreaterThanEqual,
+                Less,
+                Less,
+                GreaterEqual,
             ],
         )
     }
diff --git a/src/parse.rs b/src/parse.rs
index 042e61a..5010b26 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -86,22 +86,22 @@ impl<'code> Parser<'code> {
     fn comparison(&mut self) -> ParseResult<'code, Expr> {
         let lhs = self.term()?;
         match self.peek().map(|token| &token.kind) {
-            Some(TokenType::GreaterThan) => {
+            Some(TokenType::Greater) => {
                 let _ = self.next();
                 let rhs = self.term()?;
                 self.binary_op(lhs, BinaryOpKind::Greater, rhs)
             }
-            Some(TokenType::GreaterThanEqual) => {
+            Some(TokenType::GreaterEqual) => {
                 let _ = self.next();
                 let rhs = self.term()?;
                 self.binary_op(lhs, BinaryOpKind::GreaterEqual, rhs)
             }
-            Some(TokenType::LessThan) => {
+            Some(TokenType::Less) => {
                 let _ = self.next();
                 let rhs = self.term()?;
                 self.binary_op(lhs, BinaryOpKind::Less, rhs)
             }
-            Some(TokenType::LessThanEqual) => {
+            Some(TokenType::LessEqual) => {
                 let _ = self.next();
                 let rhs = self.term()?;
                 self.binary_op(lhs, BinaryOpKind::LessEqual, rhs)
@@ -327,17 +327,13 @@ mod test {
 
         #[test]
         fn greater() {
-            test_literal_bin_op(
-                TokenType::GreaterThan,
-                BinaryOpKind::Greater,
-                parse_comparison,
-            );
+            test_literal_bin_op(TokenType::Greater, BinaryOpKind::Greater, parse_comparison);
         }
 
         #[test]
         fn greater_equal() {
             test_literal_bin_op(
-                TokenType::GreaterThanEqual,
+                TokenType::GreaterEqual,
                 BinaryOpKind::GreaterEqual,
                 parse_comparison,
             );
@@ -345,13 +341,13 @@ mod test {
 
         #[test]
         fn less() {
-            test_literal_bin_op(TokenType::LessThan, BinaryOpKind::Less, parse_comparison);
+            test_literal_bin_op(TokenType::Less, BinaryOpKind::Less, parse_comparison);
         }
 
         #[test]
         fn less_equal() {
             test_literal_bin_op(
-                TokenType::LessThanEqual,
+                TokenType::LessEqual,
                 BinaryOpKind::LessEqual,
                 parse_comparison,
             );