diff --git a/common/src/boxvec.rs b/common/src/boxvec.rs
index 25afbcebb..1a1d57c16 100644
--- a/common/src/boxvec.rs
+++ b/common/src/boxvec.rs
@@ -550,7 +550,7 @@ impl<T> Extend<T> for BoxVec<T> {
             };
             let mut iter = iter.into_iter();
             loop {
-                if ptr == end_ptr {
+                if std::ptr::eq(ptr, end_ptr) {
                     break;
                 }
                 if let Some(elt) = iter.next() {
diff --git a/common/src/str.rs b/common/src/str.rs
index 8a00dcf1d..e72f2efb9 100644
--- a/common/src/str.rs
+++ b/common/src/str.rs
@@ -418,7 +418,7 @@ pub fn zfill(bytes: &[u8], width: usize) -> Vec<u8> {
         };
         let mut filled = Vec::new();
         filled.extend_from_slice(sign);
-        filled.extend(std::iter::repeat(b'0').take(width - bytes.len()));
+        filled.extend(std::iter::repeat_n(b'0', width - bytes.len()));
         filled.extend_from_slice(s);
         filled
     }
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
index a6eb216e2..c640b014a 100644
--- a/compiler/codegen/src/compile.rs
+++ b/compiler/codegen/src/compile.rs
@@ -1519,7 +1519,7 @@ impl Compiler<'_> {
             loop_data: None,
         };
 
-        let prev_class_name = std::mem::replace(&mut self.class_name, Some(name.to_owned()));
+        let prev_class_name = self.class_name.replace(name.to_owned());
 
         // Check if the class is declared global
         let symbol_table = self.symbol_table_stack.last().unwrap();
diff --git a/compiler/codegen/src/ir.rs b/compiler/codegen/src/ir.rs
index 2b3e49d03..39857e6fc 100644
--- a/compiler/codegen/src/ir.rs
+++ b/compiler/codegen/src/ir.rs
@@ -136,8 +136,7 @@ impl CodeInfo {
                         *arg = new_arg;
                     }
                     let (extras, lo_arg) = arg.split();
-                    locations
-                        .extend(std::iter::repeat(info.location.clone()).take(arg.instr_size()));
+                    locations.extend(std::iter::repeat_n(info.location.clone(), arg.instr_size()));
                     instructions.extend(
                         extras
                             .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
diff --git a/compiler/codegen/src/symboltable.rs b/compiler/codegen/src/symboltable.rs
index 4246700ce..4f42b3996 100644
--- a/compiler/codegen/src/symboltable.rs
+++ b/compiler/codegen/src/symboltable.rs
@@ -730,7 +730,7 @@ impl SymbolTableBuilder<'_> {
                     SymbolTableType::Class,
                     self.line_index_start(*range),
                 );
-                let prev_class = std::mem::replace(&mut self.class_name, Some(name.to_string()));
+                let prev_class = self.class_name.replace(name.to_string());
                 self.register_name("__module__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__qualname__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__doc__", SymbolUsage::Assigned, *range)?;
diff --git a/src/settings.rs b/src/settings.rs
index bc279ba28..76c46ac43 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -305,7 +305,7 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
         .then(|| get_env("PYTHONHASHSEED"))
         .flatten()
     {
-        Some(s) if s == "random" || s == "" => None,
+        Some(s) if s == "random" || s.is_empty() => None,
         Some(s) => {
             let seed = s.parse_with(|s| {
                 s.parse::<u32>().map_err(|_| {
diff --git a/stdlib/src/binascii.rs b/stdlib/src/binascii.rs
index ce3f9febd..65be2e0bd 100644
--- a/stdlib/src/binascii.rs
+++ b/stdlib/src/binascii.rs
@@ -716,7 +716,7 @@ mod decl {
                     vm,
                 ));
             }
-            let mut res = Vec::<u8>::with_capacity(2 + ((length + 2) / 3) * 4);
+            let mut res = Vec::<u8>::with_capacity(2 + length.div_ceil(3) * 4);
             res.push(uu_b2a(length as u8, backtick));
 
             for chunk in b.chunks(3) {
diff --git a/stdlib/src/csv.rs b/stdlib/src/csv.rs
index 04ebe4916..214209ab9 100644
--- a/stdlib/src/csv.rs
+++ b/stdlib/src/csv.rs
@@ -982,7 +982,7 @@ mod _csv {
             };
             loop {
                 let (res, nread, nwritten, nends) = reader.read_record(
-                    input[input_offset..].as_bytes(),
+                    &input.as_bytes()[input_offset..],
                     &mut buffer[output_offset..],
                     &mut output_ends[output_ends_offset..],
                 );
@@ -999,7 +999,7 @@ mod _csv {
                     }
                 }
             }
-            let rest = input[input_offset..].as_bytes();
+            let rest = &input.as_bytes()[input_offset..];
             if !rest.iter().all(|&c| matches!(c, b'\r' | b'\n')) {
                 return Err(new_csv_error(
                     vm,
diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs
index 89e747344..efac49d91 100644
--- a/vm/src/anystr.rs
+++ b/vm/src/anystr.rs
@@ -283,9 +283,9 @@ pub trait AnyStr {
         let mut u = Self::Container::with_capacity(
             (left + right) * fillchar.bytes_len() + self.bytes_len(),
         );
-        u.extend(std::iter::repeat(fillchar).take(left));
+        u.extend(std::iter::repeat_n(fillchar, left));
         u.push_str(self);
-        u.extend(std::iter::repeat(fillchar).take(right));
+        u.extend(std::iter::repeat_n(fillchar, right));
         u
     }
 
diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs
index 2878e5f05..55f9b814d 100644
--- a/vm/src/builtins/range.rs
+++ b/vm/src/builtins/range.rs
@@ -608,11 +608,7 @@ impl PyRangeIterator {
     #[pymethod(magic)]
     fn length_hint(&self) -> usize {
         let index = self.index.load();
-        if index < self.length {
-            self.length - index
-        } else {
-            0
-        }
+        self.length.saturating_sub(index)
     }
 
     #[pymethod(magic)]
diff --git a/vm/src/builtins/staticmethod.rs b/vm/src/builtins/staticmethod.rs
index 8e2333da7..6c19a42a3 100644
--- a/vm/src/builtins/staticmethod.rs
+++ b/vm/src/builtins/staticmethod.rs
@@ -27,8 +27,7 @@ impl GetDescriptor for PyStaticMethod {
         vm: &VirtualMachine,
     ) -> PyResult {
         let (zelf, _obj) = Self::_unwrap(&zelf, obj, vm)?;
-        let x = Ok(zelf.callable.lock().clone());
-        x
+        Ok(zelf.callable.lock().clone())
     }
 }
 
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
index 52577f0e2..1b6e28165 100644
--- a/vm/src/builtins/tuple.rs
+++ b/vm/src/builtins/tuple.rs
@@ -429,7 +429,7 @@ impl Iterable for PyTuple {
 impl Representable for PyTuple {
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let s = if zelf.len() == 0 {
+        let s = if zelf.is_empty() {
             vm.ctx.intern_str("()").to_owned()
         } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let s = if zelf.len() == 1 {
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
index c4dc23c95..b14893446 100644
--- a/vm/src/frame.rs
+++ b/vm/src/frame.rs
@@ -1147,7 +1147,7 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::FormatValue { conversion } => {
                 self.format_value(conversion.get(arg), vm)
             }
-            bytecode::Instruction::PopException {} => {
+            bytecode::Instruction::PopException => {
                 let block = self.pop_block();
                 if let BlockType::ExceptHandler { prev_exc } = block.typ {
                     vm.set_exception(prev_exc);
diff --git a/vm/src/stdlib/ctypes/base.rs b/vm/src/stdlib/ctypes/base.rs
index d07ccba30..e3e12bdf3 100644
--- a/vm/src/stdlib/ctypes/base.rs
+++ b/vm/src/stdlib/ctypes/base.rs
@@ -278,21 +278,21 @@ impl PyCSimple {
         let value = unsafe { (*self.value.as_ptr()).clone() };
         if let Ok(i) = value.try_int(vm) {
             let i = i.as_bigint();
-            if ty.as_raw_ptr() == libffi::middle::Type::u8().as_raw_ptr() {
+            if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
                 return i.to_u8().map(|r: u8| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::i8().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
                 return i.to_i8().map(|r: i8| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::u16().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
                 return i.to_u16().map(|r: u16| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::i16().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
                 return i.to_i16().map(|r: i16| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::u32().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
                 return i.to_u32().map(|r: u32| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::i32().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
                 return i.to_i32().map(|r: i32| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::u64().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
                 return i.to_u64().map(|r: u64| libffi::middle::Arg::new(&r));
-            } else if ty.as_raw_ptr() == libffi::middle::Type::i64().as_raw_ptr() {
+            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
                 return i.to_i64().map(|r: i64| libffi::middle::Arg::new(&r));
             } else {
                 return None;
diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs
index 65c148205..dab62987d 100644
--- a/vm/src/stdlib/itertools.rs
+++ b/vm/src/stdlib/itertools.rs
@@ -335,7 +335,7 @@ mod decl {
                 item
             } else {
                 let saved = zelf.saved.read();
-                if saved.len() == 0 {
+                if saved.is_empty() {
                     return Ok(PyIterReturn::StopIteration(None));
                 }
 
@@ -1332,8 +1332,7 @@ mod decl {
             for arg in iterables.iter() {
                 pools.push(arg.try_to_value(vm)?);
             }
-            let pools = std::iter::repeat(pools)
-                .take(repeat)
+            let pools = std::iter::repeat_n(pools, repeat)
                 .flatten()
                 .collect::<Vec<Vec<PyObjectRef>>>();
 
@@ -1353,7 +1352,7 @@ mod decl {
     #[pyclass(with(IterNext, Iterable, Constructor))]
     impl PyItertoolsProduct {
         fn update_idxs(&self, mut idxs: PyRwLockWriteGuard<'_, Vec<usize>>) {
-            if idxs.len() == 0 {
+            if idxs.is_empty() {
                 self.stop.store(true);
                 return;
             }
diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs
index cdd8d8c3b..0df93833b 100644
--- a/vm/src/stdlib/signal.rs
+++ b/vm/src/stdlib/signal.rs
@@ -184,10 +184,7 @@ pub(crate) mod _signal {
             siginterrupt(signalnum, 1);
         }
 
-        let old_handler = std::mem::replace(
-            &mut signal_handlers.borrow_mut()[signalnum as usize],
-            Some(handler),
-        );
+        let old_handler = signal_handlers.borrow_mut()[signalnum as usize].replace(handler);
         Ok(old_handler)
     }