diff --git a/src/errors/location.rs b/src/errors/location.rs
index d020519e7..3d3e90849 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -147,7 +147,7 @@ impl Location {
             Self::Empty => {
                 *self = Self::new_some(loc_item);
             }
-        };
+        }
     }
 }
 
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 9afe49a0a..e1b3b3792 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -10,6 +10,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 use speedate::{Date, DateTime, Duration, ParseError, Time, TimeConfig};
 use std::borrow::Cow;
 use std::collections::hash_map::DefaultHasher;
+use std::fmt::Write;
 use std::hash::Hash;
 use std::hash::Hasher;
 
@@ -59,7 +60,7 @@ impl<'py> EitherDate<'py> {
                         },
                         input,
                     ));
-                };
+                }
                 let py_date = PyDate::new(py, date.year.into(), date.month, date.day)?;
                 Ok(py_date.into())
             }
@@ -296,7 +297,7 @@ impl<'py> EitherDateTime<'py> {
                         },
                         input,
                     ));
-                };
+                }
                 let py_dt = PyDateTime::new(
                     py,
                     dt.date.year.into(),
@@ -590,7 +591,7 @@ impl TzInfo {
         );
 
         if seconds != 0 {
-            result.push_str(&format!(":{:02}", seconds.abs()));
+            write!(result, ":{:02}", seconds.abs()).expect("writing to string should never fail");
         }
 
         result
diff --git a/src/input/shared.rs b/src/input/shared.rs
index f3d8a3b9f..1a90b4142 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -181,7 +181,7 @@ fn strip_leading_zeros(s: &str) -> Option<&str> {
         Some((_, c)) if ('1'..='9').contains(&c) || c == '-' => return Some(s),
         // anything else is invalid, we return None
         _ => return None,
-    };
+    }
     for (i, c) in char_iter {
         match c {
             // continue on more leading zeros or if we get an underscore we continue - we're "within the number"
diff --git a/src/serializers/errors.rs b/src/serializers/errors.rs
index 5f736c11b..d9ba85682 100644
--- a/src/serializers/errors.rs
+++ b/src/serializers/errors.rs
@@ -1,4 +1,5 @@
 use std::fmt;
+use std::fmt::Write;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
@@ -154,7 +155,7 @@ impl PydanticSerializationUnexpectedValue {
             if !message.is_empty() {
                 message.push_str(": ");
             }
-            message.push_str(&format!("Expected `{field_type}`"));
+            write!(message, "Expected `{field_type}`").expect("writing to string should never fail");
             if self.input_value.is_some() {
                 message.push_str(" - serialized value may not be as expected");
             }
@@ -170,7 +171,8 @@ impl PydanticSerializationUnexpectedValue {
 
             let value_str = truncate_safe_repr(bound_input, None);
 
-            message.push_str(&format!(" [input_value={value_str}, input_type={input_type}]"));
+            write!(message, " [input_value={value_str}, input_type={input_type}]")
+                .expect("writing to string should never fail");
         }
 
         if message.is_empty() {
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index 86379bade..0e5050c64 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -115,10 +115,7 @@ impl TypeSerializer for GeneratorSerializer {
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyIterator>() {
             Ok(py_iter) => {
-                let len = match value.len() {
-                    Ok(len) => Some(len),
-                    Err(_) => None,
-                };
+                let len = value.len().ok();
                 let mut seq = serializer.serialize_seq(len)?;
                 let item_serializer = self.item_serializer.as_ref();
 
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index e5e3da353..e6bc6d2f0 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -243,10 +243,10 @@ impl TupleSerializer {
                         serializer: &CombinedSerializer::Any(AnySerializer),
                     }) {
                         return Ok(Err(e));
-                    };
+                    }
                 }
             }
-        };
+        }
         Ok(Ok(()))
     }
 }
diff --git a/src/url.rs b/src/url.rs
index 8d31fb27e..da63be5af 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -392,7 +392,7 @@ impl PyMultiHostUrl {
                     multi_url.push_str(&single_host.to_string());
                     if index != hosts.len() - 1 {
                         multi_url.push(',');
-                    };
+                    }
                 }
                 multi_url
             } else if host.is_some() {
@@ -456,7 +456,7 @@ impl fmt::Display for UrlHostParts {
             (None, Some(password)) => write!(f, ":{password}@")?,
             (Some(username), Some(password)) => write!(f, "{username}:{password}@")?,
             (None, None) => {}
-        };
+        }
         if let Some(host) = &self.host {
             write!(f, "{host}")?;
         }
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 7c397d69f..2da3bbfcb 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -280,7 +280,7 @@ impl Validator for ArgumentsValidator {
                             input,
                             index,
                         ));
-                    };
+                    }
                 }
             }
         }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 0f2cbefc7..e518757f2 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -190,9 +190,9 @@ impl Validator for DataclassArgsValidator {
                     // We could try to "fix" this in the future if desired.
                     Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
                     Err(err) => return Err(err),
-                };
+                }
                 continue;
-            };
+            }
 
             let mut pos_value = None;
             if let Some(args) = args.args() {
@@ -265,7 +265,7 @@ impl Validator for DataclassArgsValidator {
                                 &field.name,
                             ));
                         }
-                        Err(ValError::Omit) => continue,
+                        Err(ValError::Omit) => {}
                         Err(ValError::LineErrors(line_errors)) => {
                             for err in line_errors {
                                 // Note: this will always use the field name even if there is an alias
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 3d8c90c6e..a2a9e0b5b 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -194,7 +194,7 @@ impl Validator for DecimalValidator {
                             }
                         }
                     }
-                };
+                }
             }
         }
 
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index ffe615fe3..3da5e9d47 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -158,7 +158,7 @@ impl<T: Debug> LiteralLookup<T> {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
-        };
+        }
         if let Some(expected_py_values) = &self.expected_py_values {
             let py_input = get_py_input()?;
             for (k, id) in expected_py_values {
@@ -166,7 +166,7 @@ impl<T: Debug> LiteralLookup<T> {
                     return Ok(Some((input, &self.values[*id])));
                 }
             }
-        };
+        }
 
         // this one must be last to avoid conflicts with the other lookups, think of this
         // almost as a lax fallback
@@ -179,7 +179,7 @@ impl<T: Debug> LiteralLookup<T> {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
-        };
+        }
         Ok(None)
     }
 
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index ba1f7d1ba..b87f671ab 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -228,7 +228,7 @@ impl Validator for ModelFieldsValidator {
                             &field.name,
                         ));
                     }
-                    Err(ValError::Omit) => continue,
+                    Err(ValError::Omit) => {}
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
                             // Note: this will always use the field name even if there is an alias
@@ -334,7 +334,7 @@ impl Validator for ModelFieldsValidator {
                                 } else {
                                     model_extra_dict.set_item(&py_key, value.to_object(self.py)?)?;
                                     self.fields_set_vec.push(py_key.into());
-                                };
+                                }
                             }
                         }
                     }
@@ -368,7 +368,7 @@ impl Validator for ModelFieldsValidator {
             // from attributes, set it now so __pydantic_extra__ is always a dict if extra=allow
             if matches!(self.extra_behavior, ExtraBehavior::Allow) && model_extra_dict_op.is_none() {
                 model_extra_dict_op = Some(PyDict::new(py));
-            };
+            }
 
             Ok((model_dict, model_extra_dict_op, fields_set).into_py_any(py)?)
         }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 013db4d69..c9c122791 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -252,7 +252,7 @@ impl Validator for TypedDictValidator {
                             ));
                         }
                     }
-                    Err(ValError::Omit) => continue,
+                    Err(ValError::Omit) => {}
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
                             // Note: this will always use the field name even if there is an alias
@@ -347,7 +347,7 @@ impl Validator for TypedDictValidator {
                                     }
                                 } else {
                                     self.output_dict.set_item(py_key, value.to_object(self.py)?)?;
-                                };
+                                }
                             }
                         }
                     }
diff --git a/src/validators/union.rs b/src/validators/union.rs
index dccc09ce7..f293a9976 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -193,7 +193,7 @@ impl UnionValidator {
             match validator.validate(py, input, state) {
                 Err(ValError::LineErrors(lines)) => errors.push(validator, label.as_deref(), lines),
                 otherwise => return otherwise,
-            };
+            }
         }
 
         Err(errors.into_val_error(input))
diff --git a/src/validators/url.rs b/src/validators/url.rs
index fd386074f..d220d60ed 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -392,7 +392,7 @@ fn parse_multihost_url<'py>(
                 '\t' | '\n' | '\r' => (),
                 c if c <= &' ' => (),
                 _ => break,
-            };
+            }
             chars.next();
         } else {
             break;
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 995f2d183..9ad4eb3b9 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -215,7 +215,7 @@ impl UuidValidator {
                     input,
                 ));
             }
-        };
+        }
         Ok(uuid)
     }