diff --git a/yunq/rust/src/codegen.rs b/yunq/rust/src/codegen.rs
index 9682e23..94769f2 100644
--- a/yunq/rust/src/codegen.rs
+++ b/yunq/rust/src/codegen.rs
@@ -152,7 +152,7 @@ fn parse_field(field: &Field) -> TokenStream {
                 unimplemented!();
             }
             Type::Message(s) => {
-                let m_type = ident(&s);
+                let m_type = ident(s);
                 quote! {
                     let #name = {
                         let msg_offset = buf.at::<u32>(yunq::message::field_offset(offset, #ind))? as usize;
@@ -272,7 +272,7 @@ fn generate_method(method: &Method) -> TokenStream {
 fn generate_client(interface: &Interface) -> TokenStream {
     let client_name = interface.name.clone() + "Client";
     let name = ident(&client_name);
-    let methods = interface.methods.iter().map(|m| generate_method(&m));
+    let methods = interface.methods.iter().map(generate_method);
     quote! {
         pub struct #name {
             endpoint_cap: Capability,
@@ -350,8 +350,8 @@ fn generate_server_method(method: &Method) -> TokenStream {
 fn generate_server(interface: &Interface) -> TokenStream {
     let server_name = ident(&(interface.name.clone() + "Server"));
     let server_trait = ident(&(interface.name.clone() + "ServerHandler"));
-    let server_trait_methods = interface.methods.iter().map(|m| generate_server_method(&m));
-    let server_match_cases = interface.methods.iter().map(|m| generate_server_case(&m));
+    let server_trait_methods = interface.methods.iter().map(generate_server_method);
+    let server_match_cases = interface.methods.iter().map(generate_server_case);
     quote! {
         pub trait #server_trait {
             #(#server_trait_methods)*
@@ -402,7 +402,7 @@ fn generate_interface(interface: &Interface) -> TokenStream {
     }
 }
 
-fn any_strings(ast: &Vec<Decl>) -> bool {
+fn any_strings(ast: &[Decl]) -> bool {
     ast.iter()
         .filter_map(|decl| match decl {
             Decl::Message(m) => Some(m),
@@ -412,14 +412,11 @@ fn any_strings(ast: &Vec<Decl>) -> bool {
         .any(|field| field.field_type.inner_type == Type::String)
 }
 
-fn any_interfaces(ast: &Vec<Decl>) -> bool {
-    ast.iter().any(|decl| match decl {
-        Decl::Interface(_) => true,
-        _ => false,
-    })
+fn any_interfaces(ast: &[Decl]) -> bool {
+    ast.iter().any(|decl| matches!(decl, Decl::Interface(_)))
 }
 
-pub fn generate_code(ast: &Vec<Decl>) -> String {
+pub fn generate_code(ast: &[Decl]) -> String {
     let str_imports = if any_strings(ast) {
         quote! {
             use alloc::string::String;
@@ -460,7 +457,7 @@ pub fn generate_code(ast: &Vec<Decl>) -> String {
             Decl::Message(m) => Some(m),
             _ => None,
         })
-        .map(|message| generate_message(&message));
+        .map(generate_message);
 
     let interface_decls = ast
         .iter()
@@ -468,7 +465,7 @@ pub fn generate_code(ast: &Vec<Decl>) -> String {
             Decl::Interface(i) => Some(i),
             _ => None,
         })
-        .map(|interface| generate_interface(&interface));
+        .map(generate_interface);
 
     let output = quote! {
         #prelude
diff --git a/yunq/rust/src/parser.rs b/yunq/rust/src/parser.rs
index fc9ac19..3ea7e2b 100644
--- a/yunq/rust/src/parser.rs
+++ b/yunq/rust/src/parser.rs
@@ -169,7 +169,7 @@ impl<'a> Parser<'a> {
             && self.tokens[self.current_index].token_type == tok_type
     }
 
-    fn consume_token<'b>(&'b mut self) -> &'b Token {
+    fn consume_token(&mut self) -> &Token {
         if self.current_index >= self.tokens.len() {
             panic!("Consumed tokens past end of input.")
         }
@@ -179,7 +179,7 @@ impl<'a> Parser<'a> {
         t
     }
 
-    fn consume_token_type<'b>(&'b mut self, t: TokenType) -> Result<&'b Token, String> {
+    fn consume_token_type(&mut self, t: TokenType) -> Result<&Token, String> {
         let token = self.consume_token();
         if token.token_type == t {
             Ok(token)
@@ -188,7 +188,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn consume_identifier<'b>(&'b mut self) -> Result<&'b Token, String> {
+    fn consume_identifier(&mut self) -> Result<&Token, String> {
         self.consume_token_type(TokenType::Name)
     }