diff --git a/molang_proc_macro/src/lib.rs b/molang_proc_macro/src/lib.rs
index 87e8100..be0785d 100644
--- a/molang_proc_macro/src/lib.rs
+++ b/molang_proc_macro/src/lib.rs
@@ -22,10 +22,7 @@ fn molang_struct(input: TokenStream) -> TokenStream {
         .map(|field| field.ident.clone().unwrap())
         .collect();
 
-    let field_types: Vec<Type> = fields
-        .iter()
-        .map(|field| field.ty.clone())
-        .collect();
+    let field_types: Vec<Type> = fields.iter().map(|field| field.ty.clone()).collect();
 
     quote! {
         impl molang::ToMolangValue for #name {
@@ -65,4 +62,4 @@ fn my_test() {
         })
     );
     panic!("abc");
-}
\ No newline at end of file
+}
diff --git a/src/data.rs b/src/data.rs
index 0160d01..ee86fb9 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -23,4 +23,4 @@ impl Operator {
             Self::Equality => 8,
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/interpreter.rs b/src/interpreter.rs
index bd7e290..96a353d 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -147,16 +147,14 @@ pub fn run(
                                         if let Some(some_current) = variables.get_mut(name) {
                                             current = some_current;
                                             break;
+                                        } else if constants.contains_key(name) {
+                                            return Err(MolangError::NotAssignable(format!(
+                                                "Constant {name}"
+                                            )));
                                         } else {
-                                            if constants.contains_key(name) {
-                                                return Err(MolangError::NotAssignable(format!(
-                                                    "Constant {name}"
-                                                )));
-                                            } else {
-                                                return Err(MolangError::VariableNotFound(
-                                                    format!("{name}"),
-                                                ));
-                                            }
+                                            return Err(MolangError::VariableNotFound(
+                                                name.to_string(),
+                                            ));
                                         }
                                     }
                                 } else if let Value::Struct(struc) =
diff --git a/src/parser.rs b/src/parser.rs
index aec57cd..3b4b038 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -62,7 +62,7 @@ pub fn treeify(mut tokens: &[Token]) -> Result<Expr, CompileError> {
         let left = &tokens[..i];
         let right = &tokens[i + 1..];
 
-        return Ok(Expr::Derived(Box::new(match op {
+        Ok(Expr::Derived(Box::new(match op {
             Operator::Not => {
                 if !left.is_empty() {
                     return Err(CompileError::TokensBeforePrefixOperator);
@@ -80,10 +80,10 @@ pub fn treeify(mut tokens: &[Token]) -> Result<Expr, CompileError> {
             Operator::NullishCoalescing => {
                 Instruction::NullishCoalescing(treeify(left)?, treeify(right)?)
             }
-        })));
+        })))
     } else {
         match tokens {
-            [Token::Number(n)] => return Ok(Expr::Literal(Value::Number(*n))),
+            [Token::Number(n)] => Ok(Expr::Literal(Value::Number(*n))),
             [Token::Access(accesses)] => {
                 let mut access_exprs = Vec::new();
                 for access in accesses {
@@ -109,7 +109,7 @@ pub fn treeify(mut tokens: &[Token]) -> Result<Expr, CompileError> {
     }
 }
 
-fn comma_split<'a>(tokens: &'a Vec<Token>) -> Vec<&'a [Token]> {
+fn comma_split(tokens: &[Token]) -> Vec<&[Token]> {
     let mut result = Vec::new();
     let mut start = 0;
 
@@ -123,7 +123,7 @@ fn comma_split<'a>(tokens: &'a Vec<Token>) -> Vec<&'a [Token]> {
     result.push(&tokens[start..]);
 
     if let Some(last) = result.pop() {
-        if last.len() != 0 {
+        if !last.is_empty() {
             result.push(last);
         }
     }
diff --git a/src/state.rs b/src/state.rs
index ebcf358..362e254 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -2,11 +2,18 @@ pub trait State<In, Out, Error> {
     fn handle(
         &mut self,
         c: Option<In>,
-    ) -> Result<(Option<Out>, Option<Box<dyn State<In, Out, Error>>>, SequenceAction), Error>;
+    ) -> Result<
+        (
+            Option<Out>,
+            Option<Box<dyn State<In, Out, Error>>>,
+            SequenceAction,
+        ),
+        Error,
+    >;
 }
 
 pub enum SequenceAction {
     Advance,
     Done,
     Hold,
-}
\ No newline at end of file
+}
diff --git a/src/tokeniser.rs b/src/tokeniser.rs
index 9cd2e1c..6718df7 100644
--- a/src/tokeniser.rs
+++ b/src/tokeniser.rs
@@ -201,16 +201,12 @@ impl State<char, Token, TokeniseError> for AccessTokenState {
     > {
         let (access, new_state, action) = self.state.handle(c)?;
 
-        match access {
-            Some(access) => self.accesses.push(access),
-            None => {}
+        if let Some(access) = access {
+            self.accesses.push(access)
         }
 
-        match new_state {
-            Some(new_state) => {
-                self.state = new_state;
-            }
-            None => {}
+        if let Some(new_state) = new_state {
+            self.state = new_state;
         }
 
         match action {