diff --git a/crates/nu-ansi-term/src/ansi.rs b/crates/nu-ansi-term/src/ansi.rs
index a70fe03df..8f2454dba 100644
--- a/crates/nu-ansi-term/src/ansi.rs
+++ b/crates/nu-ansi-term/src/ansi.rs
@@ -93,7 +93,7 @@ pub static RESET: &str = "\x1B[0m";
 
 impl Color {
     fn write_foreground_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
+        match self {
             Color::Black => write!(f, "30"),
             Color::Red => write!(f, "31"),
             Color::Green => write!(f, "32"),
@@ -103,8 +103,8 @@ impl Color {
             Color::Magenta => write!(f, "35"),
             Color::Cyan => write!(f, "36"),
             Color::White => write!(f, "37"),
-            Color::Fixed(num) => write!(f, "38;5;{}", &num),
-            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
+            Color::Fixed(num) => write!(f, "38;5;{}", num),
+            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", r, g, b),
             Color::DarkGray => write!(f, "90"),
             Color::LightRed => write!(f, "91"),
             Color::LightGreen => write!(f, "92"),
@@ -118,7 +118,7 @@ impl Color {
     }
 
     fn write_background_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
+        match self {
             Color::Black => write!(f, "40"),
             Color::Red => write!(f, "41"),
             Color::Green => write!(f, "42"),
@@ -128,8 +128,8 @@ impl Color {
             Color::Magenta => write!(f, "45"),
             Color::Cyan => write!(f, "46"),
             Color::White => write!(f, "47"),
-            Color::Fixed(num) => write!(f, "48;5;{}", &num),
-            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
+            Color::Fixed(num) => write!(f, "48;5;{}", num),
+            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", r, g, b),
             Color::DarkGray => write!(f, "100"),
             Color::LightRed => write!(f, "101"),
             Color::LightGreen => write!(f, "102"),
diff --git a/crates/nu-ansi-term/src/display.rs b/crates/nu-ansi-term/src/display.rs
index 32c7acd08..db5221f35 100644
--- a/crates/nu-ansi-term/src/display.rs
+++ b/crates/nu-ansi-term/src/display.rs
@@ -297,7 +297,7 @@ mod tests {
     fn no_control_codes_for_plain() {
         let one = Style::default().paint("one");
         let two = Style::default().paint("two");
-        let output = format!("{}", AnsiStrings(&[one, two]));
-        assert_eq!(&*output, "onetwo");
+        let output = AnsiStrings(&[one, two]).to_string();
+        assert_eq!(output, "onetwo");
     }
 }
diff --git a/crates/nu-ansi-term/src/style.rs b/crates/nu-ansi-term/src/style.rs
index a11002e02..53b506496 100644
--- a/crates/nu-ansi-term/src/style.rs
+++ b/crates/nu-ansi-term/src/style.rs
@@ -602,14 +602,14 @@ mod serde_json_tests {
 
     #[test]
     fn color_deserialization() {
-        let colors = &[
+        let colors = [
             Color::Red,
             Color::Blue,
             Color::Rgb(123, 123, 123),
             Color::Fixed(255),
         ];
 
-        for color in colors.iter() {
+        for color in colors {
             let serialized = serde_json::to_string(&color).unwrap();
             let deserialized: Color = serde_json::from_str(&serialized).unwrap();
 
diff --git a/crates/nu-ansi-term/src/util.rs b/crates/nu-ansi-term/src/util.rs
index 5fd6f4818..d66645958 100644
--- a/crates/nu-ansi-term/src/util.rs
+++ b/crates/nu-ansi-term/src/util.rs
@@ -75,6 +75,6 @@ mod test {
         assert_eq!(unstyled_len(&a), 18);
 
         let l2 = [Black.paint("st"), Red.paint("-second"), White.paint("-t")];
-        assert_eq!(sub_string(3, 11, &a).as_slice(), &l2);
+        assert_eq!(sub_string(3, 11, &a), l2);
     }
 }
diff --git a/crates/nu-cli/src/app.rs b/crates/nu-cli/src/app.rs
index 4d04a3f32..952a70d38 100644
--- a/crates/nu-cli/src/app.rs
+++ b/crates/nu-cli/src/app.rs
@@ -508,14 +508,14 @@ mod tests {
 
     #[test]
     fn can_use_loglevels() -> Result<(), ShellError> {
-        for level in &["error", "warn", "info", "debug", "trace"] {
+        for level in ["error", "warn", "info", "debug", "trace"] {
             let ui = cli_app();
-            let args = format!("nu --loglevel={}", *level);
+            let args = format!("nu --loglevel={}", level);
             ui.parse(&args)?;
             assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
 
             let ui = cli_app();
-            let args = format!("nu -l {}", *level);
+            let args = format!("nu -l {}", level);
             ui.parse(&args)?;
             assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
         }
@@ -541,11 +541,11 @@ mod tests {
 
     #[test]
     fn can_use_test_binaries() -> Result<(), ShellError> {
-        for binarie_name in &[
+        for binarie_name in [
             "echo_env", "cococo", "iecho", "fail", "nonu", "chop", "repeater", "meow",
         ] {
             let ui = cli_app();
-            let args = format!("nu --testbin={}", *binarie_name);
+            let args = format!("nu --testbin={}", binarie_name);
             ui.parse(&args)?;
             assert_eq!(ui.testbin().unwrap(), Ok(binarie_name.to_string()));
         }
diff --git a/crates/nu-cli/src/app/options.rs b/crates/nu-cli/src/app/options.rs
index d68cf7050..025316578 100644
--- a/crates/nu-cli/src/app/options.rs
+++ b/crates/nu-cli/src/app/options.rs
@@ -44,7 +44,7 @@ impl Options {
     }
 
     pub fn get(&self, key: &str) -> Option<Value> {
-        self.inner.borrow().get(key).map(Clone::clone)
+        self.inner.borrow().get(key).cloned()
     }
 
     pub fn put(&self, key: &str, value: Value) {
diff --git a/crates/nu-cli/src/app/options_parser.rs b/crates/nu-cli/src/app/options_parser.rs
index 938d17593..d6efb6b0b 100644
--- a/crates/nu-cli/src/app/options_parser.rs
+++ b/crates/nu-cli/src/app/options_parser.rs
@@ -67,48 +67,37 @@ impl OptionsParser for NuParser {
                             }
                         };
 
-                        let value =
-                            value
-                                .map(|v| match k.as_ref() {
-                                    "testbin" => {
-                                        if let Ok(name) = v.as_string() {
-                                            if testbins().iter().any(|n| name == *n) {
-                                                Some(v)
-                                            } else {
-                                                Some(
-                                                    UntaggedValue::Error(
-                                                        ShellError::untagged_runtime_error(
-                                                            format!("{} is not supported.", name),
-                                                        ),
-                                                    )
-                                                    .into_value(v.tag),
-                                                )
-                                            }
-                                        } else {
-                                            Some(v)
-                                        }
+                        let value = value.map(|v| match k.as_ref() {
+                            "testbin" => {
+                                if let Ok(name) = v.as_string() {
+                                    if testbins().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
                                     }
-                                    "loglevel" => {
-                                        if let Ok(name) = v.as_string() {
-                                            if loglevels().iter().any(|n| name == *n) {
-                                                Some(v)
-                                            } else {
-                                                Some(
-                                                    UntaggedValue::Error(
-                                                        ShellError::untagged_runtime_error(
-                                                            format!("{} is not supported.", name),
-                                                        ),
-                                                    )
-                                                    .into_value(v.tag),
-                                                )
-                                            }
-                                        } else {
-                                            Some(v)
-                                        }
+                                } else {
+                                    v
+                                }
+                            }
+                            "loglevel" => {
+                                if let Ok(name) = v.as_string() {
+                                    if loglevels().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
                                     }
-                                    _ => Some(v),
-                                })
-                                .flatten();
+                                } else {
+                                    v
+                                }
+                            }
+                            _ => v,
+                        });
 
                         if let Some(value) = value {
                             options.put(k, value);
diff --git a/crates/nu-cli/src/cli.rs b/crates/nu-cli/src/cli.rs
index a2c184731..96742501f 100644
--- a/crates/nu-cli/src/cli.rs
+++ b/crates/nu-cli/src/cli.rs
@@ -165,7 +165,10 @@ pub fn cli(
     // Store cmd duration in an env var
     context.scope.add_env_var(
         "CMD_DURATION_MS",
-        format!("{}", startup_commands_start_time.elapsed().as_millis()),
+        startup_commands_start_time
+            .elapsed()
+            .as_millis()
+            .to_string(),
     );
 
     if options.perf {
@@ -353,7 +356,7 @@ pub fn cli(
         // Store cmd duration in an env var
         context.scope.add_env_var(
             "CMD_DURATION_MS",
-            format!("{}", cmd_start_time.elapsed().as_millis()),
+            cmd_start_time.elapsed().as_millis().to_string(),
         );
 
         match line {
@@ -397,8 +400,7 @@ pub fn cli(
                     .lock()
                     .global_config
                     .as_ref()
-                    .map(|cfg| cfg.var("ctrlc_exit"))
-                    .flatten()
+                    .and_then(|cfg| cfg.var("ctrlc_exit"))
                     .map(|ctrl_c| ctrl_c.is_true())
                     .unwrap_or(false); // default behavior is to allow CTRL-C spamming similar to other shells
 
diff --git a/crates/nu-cli/src/keybinding.rs b/crates/nu-cli/src/keybinding.rs
index a5cea6c7f..0b90255ed 100644
--- a/crates/nu-cli/src/keybinding.rs
+++ b/crates/nu-cli/src/keybinding.rs
@@ -461,7 +461,7 @@ pub(crate) fn load_keybindings(
     if let Ok(contents) = contents {
         let keybindings: Keybindings = serde_yaml::from_str(&contents)?;
         // eprintln!("{:#?}", keybindings);
-        for keybinding in keybindings.into_iter() {
+        for keybinding in keybindings {
             let (k, b) = convert_keybinding(keybinding);
             // eprintln!("{:?} {:?}", k, b);
 
diff --git a/crates/nu-command/src/classified/external.rs b/crates/nu-command/src/classified/external.rs
index ac8148abe..8168a93a7 100644
--- a/crates/nu-command/src/classified/external.rs
+++ b/crates/nu-command/src/classified/external.rs
@@ -509,7 +509,7 @@ fn spawn(
             Ok(stream.into_input_stream())
         }
         Err(e) => Err(ShellError::labeled_error(
-            format!("{}", e),
+            e.to_string(),
             "failed to spawn",
             &command.name_tag,
         )),
diff --git a/crates/nu-command/src/commands/conversions/into/string.rs b/crates/nu-command/src/commands/conversions/into/string.rs
index dfa52c690..70f19fe66 100644
--- a/crates/nu-command/src/commands/conversions/into/string.rs
+++ b/crates/nu-command/src/commands/conversions/into/string.rs
@@ -159,7 +159,7 @@ pub fn action(
 }
 
 fn format_int(int: i64) -> String {
-    format!("{}", int)
+    int.to_string()
 
     // TODO once platform-specific dependencies are stable (see Cargo.toml)
     // #[cfg(windows)]
@@ -176,7 +176,7 @@ fn format_int(int: i64) -> String {
 }
 
 fn format_bigint(int: &BigInt) -> String {
-    format!("{}", int)
+    int.to_string()
 
     // TODO once platform-specific dependencies are stable (see Cargo.toml)
     // #[cfg(windows)]
@@ -230,7 +230,7 @@ fn format_decimal(mut decimal: BigDecimal, digits: Option<u64>, group_digits: bo
     let format_default_loc = |int_part: BigInt| {
         let loc = Locale::en;
         //TODO: when num_format is available for recent bigint, replace this with the locale-based format
-        let (int_str, sep) = (format!("{}", int_part), String::from(loc.decimal()));
+        let (int_str, sep) = (int_part.to_string(), String::from(loc.decimal()));
 
         format!("{}{}{}", int_str, sep, dec_str)
     };
diff --git a/crates/nu-command/src/commands/core_commands/error/make.rs b/crates/nu-command/src/commands/core_commands/error/make.rs
index e47aa04d2..0d3ca69fe 100644
--- a/crates/nu-command/src/commands/core_commands/error/make.rs
+++ b/crates/nu-command/src/commands/core_commands/error/make.rs
@@ -55,17 +55,18 @@ fn make_error(value: &Value) -> Option<ShellError> {
     {
         let msg = dict.get_data_by_key("msg".spanned_unknown());
 
-        let labels = dict
-            .get_data_by_key("labels".spanned_unknown())
-            .map(|table| match &table.value {
-                UntaggedValue::Table(_) => table
-                    .table_entries()
-                    .map(|value| value.as_string().ok())
-                    .collect(),
-                UntaggedValue::Primitive(Primitive::String(label)) => Some(vec![label.to_string()]),
-                _ => None,
-            })
-            .flatten();
+        let labels =
+            dict.get_data_by_key("labels".spanned_unknown())
+                .and_then(|table| match &table.value {
+                    UntaggedValue::Table(_) => table
+                        .table_entries()
+                        .map(|value| value.as_string().ok())
+                        .collect(),
+                    UntaggedValue::Primitive(Primitive::String(label)) => {
+                        Some(vec![label.to_string()])
+                    }
+                    _ => None,
+                });
 
         let _anchor = dict.get_data_by_key("tag".spanned_unknown());
         let span = dict.get_data_by_key("span".spanned_unknown());
@@ -74,7 +75,7 @@ fn make_error(value: &Value) -> Option<ShellError> {
             return None;
         }
 
-        let msg = msg.map(|msg| msg.as_string().ok()).flatten();
+        let msg = msg.and_then(|msg| msg.as_string().ok());
 
         if let Some(labels) = labels {
             if labels.is_empty() {
diff --git a/crates/nu-command/src/commands/core_commands/find.rs b/crates/nu-command/src/commands/core_commands/find.rs
index 7b27838f5..559f9fa3b 100644
--- a/crates/nu-command/src/commands/core_commands/find.rs
+++ b/crates/nu-command/src/commands/core_commands/find.rs
@@ -50,7 +50,7 @@ impl WholeStreamCommand for Find {
 
 fn row_contains(row: &Dictionary, search_terms: Vec<String>) -> bool {
     for term in search_terms {
-        for (k, v) in row.entries.iter() {
+        for (k, v) in &row.entries {
             let key = k.to_string().trim().to_lowercase();
             let value = v.convert_to_string().trim().to_lowercase();
             if key.contains(&term) || value.contains(&term) {
diff --git a/crates/nu-command/src/commands/core_commands/help.rs b/crates/nu-command/src/commands/core_commands/help.rs
index 8eb39ca75..08a74bffa 100644
--- a/crates/nu-command/src/commands/core_commands/help.rs
+++ b/crates/nu-command/src/commands/core_commands/help.rs
@@ -302,7 +302,7 @@ pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
     let tag = tag.into();
     let mut sig = TaggedListBuilder::new(&tag);
 
-    for arg in signature.positional.iter() {
+    for arg in &signature.positional {
         let is_required = matches!(arg.0, PositionalType::Mandatory(_, _));
 
         sig.push_value(for_spec(arg.0.name(), "argument", is_required, &tag));
@@ -313,7 +313,7 @@ pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
         sig.push_value(for_spec("rest", "argument", is_required, &tag));
     }
 
-    for (name, ty) in signature.named.iter() {
+    for (name, ty) in &signature.named {
         match ty.0 {
             NamedType::Mandatory(_, _) => sig.push_value(for_spec(name, "flag", true, &tag)),
             NamedType::Optional(_, _) => sig.push_value(for_spec(name, "flag", false, &tag)),
diff --git a/crates/nu-command/src/commands/core_commands/if_.rs b/crates/nu-command/src/commands/core_commands/if_.rs
index 70a293623..0eba1c321 100644
--- a/crates/nu-command/src/commands/core_commands/if_.rs
+++ b/crates/nu-command/src/commands/core_commands/if_.rs
@@ -100,14 +100,14 @@ fn if_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
     context.scope.add_vars(&condition.captured.entries);
 
     //FIXME: should we use the scope that's brought in as well?
-    let condition = evaluate_baseline_expr(cond, &*context);
+    let condition = evaluate_baseline_expr(cond, &context);
     match condition {
         Ok(condition) => match condition.as_bool() {
             Ok(b) => {
                 let result = if b {
-                    run_block(&then_case.block, &*context, input, external_redirection)
+                    run_block(&then_case.block, &context, input, external_redirection)
                 } else {
-                    run_block(&else_case.block, &*context, input, external_redirection)
+                    run_block(&else_case.block, &context, input, external_redirection)
                 };
                 context.scope.exit_scope();
 
diff --git a/crates/nu-command/src/commands/core_commands/tutor.rs b/crates/nu-command/src/commands/core_commands/tutor.rs
index 2538ccbdb..472106244 100644
--- a/crates/nu-command/src/commands/core_commands/tutor.rs
+++ b/crates/nu-command/src/commands/core_commands/tutor.rs
@@ -56,7 +56,7 @@ fn tutor(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let search: Option<String> = args.opt(0).unwrap_or(None);
     let find: Option<String> = args.get_flag("find")?;
 
-    let search_space = vec![
+    let search_space = [
         (vec!["begin"], begin_tutor()),
         (
             vec!["table", "tables", "row", "rows", "column", "columns"],
@@ -88,7 +88,7 @@ fn tutor(args: CommandArgs) -> Result<OutputStream, ShellError> {
     if let Some(find) = find {
         let mut results = vec![];
         for search_group in search_space {
-            if search_group.1.contains(&find.as_str()) {
+            if search_group.1.contains(&find) {
                 results.push(search_group.0[0].to_string())
             }
         }
@@ -383,7 +383,7 @@ fn display(tag: Tag, scope: &Scope, help: &str) -> OutputStream {
 
             //TODO: support no-color mode
             let colored_example = nu_engine::Painter::paint_string(item, scope, &palette);
-            build.push_str(&format!("{}", colored_example));
+            build.push_str(&colored_example);
         } else {
             code_mode = true;
             build.push_str(item);
diff --git a/crates/nu-command/src/commands/dataframe/aggregate.rs b/crates/nu-command/src/commands/dataframe/aggregate.rs
index c6612d94d..b5649a56b 100644
--- a/crates/nu-command/src/commands/dataframe/aggregate.rs
+++ b/crates/nu-command/src/commands/dataframe/aggregate.rs
@@ -245,7 +245,7 @@ fn perform_groupby_aggregation(
                 None => &col[..],
             };
 
-            res.rename(col.as_str(), new_col)
+            res.rename(&col, new_col)
                 .expect("Column is always there. Looping with known names");
         }
     }
diff --git a/crates/nu-command/src/commands/dataframe/append.rs b/crates/nu-command/src/commands/dataframe/append.rs
index a2f23ba4e..503daac65 100644
--- a/crates/nu-command/src/commands/dataframe/append.rs
+++ b/crates/nu-command/src/commands/dataframe/append.rs
@@ -107,7 +107,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let other: Value = args.req_named("other")?;
     let axis: Tagged<String> = args.req_named("axis")?;
 
-    let axis = Axis::try_from_str(axis.item.as_str(), &axis.tag.span)?;
+    let axis = Axis::try_from_str(&axis.item, &axis.tag.span)?;
 
     let df_other = match other.value {
         UntaggedValue::DataFrame(df) => Ok(df),
diff --git a/crates/nu-command/src/commands/dataframe/column.rs b/crates/nu-command/src/commands/dataframe/column.rs
index 8f76fae00..e0b566818 100644
--- a/crates/nu-command/src/commands/dataframe/column.rs
+++ b/crates/nu-command/src/commands/dataframe/column.rs
@@ -53,7 +53,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     let res = df
         .as_ref()
-        .column(column.item.as_ref())
+        .column(&column.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &column.tag.span, None))?;
 
     let df = NuDataFrame::try_from_series(vec![res.clone()], &tag.span)?;
diff --git a/crates/nu-command/src/commands/dataframe/describe.rs b/crates/nu-command/src/commands/dataframe/describe.rs
index ff452d728..41a6da1a9 100644
--- a/crates/nu-command/src/commands/dataframe/describe.rs
+++ b/crates/nu-command/src/commands/dataframe/describe.rs
@@ -195,7 +195,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
         let name = format!("{} ({})", col.name(), col.dtype());
         ChunkedArray::<Float64Type>::new_from_opt_slice(
-            name.as_str(),
+            &name,
             &[
                 Some(count),
                 sum,
diff --git a/crates/nu-command/src/commands/dataframe/dtypes.rs b/crates/nu-command/src/commands/dataframe/dtypes.rs
index 4ec6c5aef..ac997ef55 100644
--- a/crates/nu-command/src/commands/dataframe/dtypes.rs
+++ b/crates/nu-command/src/commands/dataframe/dtypes.rs
@@ -72,7 +72,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
                 .expect("using name from list of names from dataframe")
                 .dtype();
 
-            let dtype_str = format!("{}", dtype);
+            let dtype_str = dtype.to_string();
             dtypes.push(Value {
                 value: dtype_str.into(),
                 tag: Tag::default(),
diff --git a/crates/nu-command/src/commands/dataframe/join.rs b/crates/nu-command/src/commands/dataframe/join.rs
index 78bab021e..66dddda5d 100644
--- a/crates/nu-command/src/commands/dataframe/join.rs
+++ b/crates/nu-command/src/commands/dataframe/join.rs
@@ -177,7 +177,7 @@ fn check_column_datatypes<T: AsRef<str>>(
         ));
     }
 
-    for (l, r) in l_cols.iter().zip(r_cols.iter()) {
+    for (l, r) in l_cols.iter().zip(r_cols) {
         let l_series = df_l
             .column(l.as_ref())
             .map_err(|e| parse_polars_error::<&str>(&e, l_col_span, None))?;
diff --git a/crates/nu-command/src/commands/dataframe/melt.rs b/crates/nu-command/src/commands/dataframe/melt.rs
index a1e509f70..702571920 100644
--- a/crates/nu-command/src/commands/dataframe/melt.rs
+++ b/crates/nu-command/src/commands/dataframe/melt.rs
@@ -135,12 +135,12 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
 
     if let Some(name) = &variable_name {
-        res.rename("variable", name.item.as_str())
+        res.rename("variable", &name.item)
             .map_err(|e| parse_polars_error::<&str>(&e, &name.tag.span, None))?;
     }
 
     if let Some(name) = &value_name {
-        res.rename("value", name.item.as_str())
+        res.rename("value", &name.item)
             .map_err(|e| parse_polars_error::<&str>(&e, &name.tag.span, None))?;
     }
 
diff --git a/crates/nu-command/src/commands/dataframe/pivot.rs b/crates/nu-command/src/commands/dataframe/pivot.rs
index 643040036..22dfa2728 100644
--- a/crates/nu-command/src/commands/dataframe/pivot.rs
+++ b/crates/nu-command/src/commands/dataframe/pivot.rs
@@ -100,7 +100,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     let mut groupby = nu_groupby.to_groupby()?;
 
-    let pivot = groupby.pivot(pivot_col.item.as_ref(), value_col.item.as_ref());
+    let pivot = groupby.pivot(&pivot_col.item, &value_col.item);
 
     let res = match op {
         Operation::Mean => pivot.mean(),
@@ -120,7 +120,7 @@ fn check_pivot_column(
     col: &Tagged<String>,
 ) -> Result<(), ShellError> {
     let series = df
-        .column(col.item.as_ref())
+        .column(&col.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &col.tag.span, None))?;
 
     match series.dtype() {
@@ -146,7 +146,7 @@ fn check_value_column(
     col: &Tagged<String>,
 ) -> Result<(), ShellError> {
     let series = df
-        .column(col.item.as_ref())
+        .column(&col.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &col.tag.span, None))?;
 
     match series.dtype() {
diff --git a/crates/nu-command/src/commands/dataframe/rename.rs b/crates/nu-command/src/commands/dataframe/rename.rs
index d29e50cf7..28e922b6d 100644
--- a/crates/nu-command/src/commands/dataframe/rename.rs
+++ b/crates/nu-command/src/commands/dataframe/rename.rs
@@ -61,7 +61,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let (mut df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     df.as_mut()
-        .rename(from.item.as_str(), to.item.as_str())
+        .rename(&from.item, &to.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
 
     Ok(OutputStream::one(df.into_value(tag)))
diff --git a/crates/nu-command/src/commands/dataframe/series/contains.rs b/crates/nu-command/src/commands/dataframe/series/contains.rs
index 8e0ead876..b99f6f715 100644
--- a/crates/nu-command/src/commands/dataframe/series/contains.rs
+++ b/crates/nu-command/src/commands/dataframe/series/contains.rs
@@ -68,7 +68,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     })?;
 
     let res = chunked
-        .contains(pattern.as_str())
+        .contains(&pattern.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
 
     let df = NuDataFrame::try_from_series(vec![res.into_series()], &tag.span)?;
diff --git a/crates/nu-command/src/commands/dataframe/series/cumulative.rs b/crates/nu-command/src/commands/dataframe/series/cumulative.rs
index 7846b41bf..e59340c74 100644
--- a/crates/nu-command/src/commands/dataframe/series/cumulative.rs
+++ b/crates/nu-command/src/commands/dataframe/series/cumulative.rs
@@ -99,7 +99,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         ));
     }
 
-    let cum_type = CumType::from_str(cum_type.item.as_str(), &cum_type.tag.span)?;
+    let cum_type = CumType::from_str(&cum_type.item, &cum_type.tag.span)?;
     let mut res = match cum_type {
         CumType::Max => series.cum_max(reverse),
         CumType::Min => series.cum_min(reverse),
diff --git a/crates/nu-command/src/commands/dataframe/series/rename.rs b/crates/nu-command/src/commands/dataframe/series/rename.rs
index aa74d6d86..d14b49a7a 100644
--- a/crates/nu-command/src/commands/dataframe/series/rename.rs
+++ b/crates/nu-command/src/commands/dataframe/series/rename.rs
@@ -60,7 +60,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     let mut series = df.as_series(&df_tag.span)?;
 
-    series.rename(name.item.as_ref());
+    series.rename(&name.item);
 
     let df = NuDataFrame::try_from_series(vec![series], &tag.span)?;
     Ok(OutputStream::one(df.into_value(df_tag)))
diff --git a/crates/nu-command/src/commands/dataframe/series/replace.rs b/crates/nu-command/src/commands/dataframe/series/replace.rs
index fe2e89a71..7e3fc6ef6 100644
--- a/crates/nu-command/src/commands/dataframe/series/replace.rs
+++ b/crates/nu-command/src/commands/dataframe/series/replace.rs
@@ -77,7 +77,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     })?;
 
     let mut res = chunked
-        .replace(pattern.as_str(), replace.as_str())
+        .replace(&pattern.item, &replace.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
 
     res.rename(series.name());
diff --git a/crates/nu-command/src/commands/dataframe/series/replace_all.rs b/crates/nu-command/src/commands/dataframe/series/replace_all.rs
index cd38bc7b8..6834391e4 100644
--- a/crates/nu-command/src/commands/dataframe/series/replace_all.rs
+++ b/crates/nu-command/src/commands/dataframe/series/replace_all.rs
@@ -77,7 +77,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     })?;
 
     let mut res = chunked
-        .replace_all(pattern.as_str(), replace.as_str())
+        .replace_all(&pattern.item, &replace.item)
         .map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
 
     res.rename(series.name());
diff --git a/crates/nu-command/src/commands/dataframe/series/rolling.rs b/crates/nu-command/src/commands/dataframe/series/rolling.rs
index 7a60ddd53..316473d84 100644
--- a/crates/nu-command/src/commands/dataframe/series/rolling.rs
+++ b/crates/nu-command/src/commands/dataframe/series/rolling.rs
@@ -125,7 +125,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         ));
     }
 
-    let roll_type = RollType::from_str(roll_type.item.as_str(), &roll_type.tag.span)?;
+    let roll_type = RollType::from_str(&roll_type.item, &roll_type.tag.span)?;
     let res = match roll_type {
         RollType::Max => series.rolling_max(
             window_size.item as u32,
diff --git a/crates/nu-command/src/commands/dataframe/series/strftime.rs b/crates/nu-command/src/commands/dataframe/series/strftime.rs
index 524a699b7..1c8c8231e 100644
--- a/crates/nu-command/src/commands/dataframe/series/strftime.rs
+++ b/crates/nu-command/src/commands/dataframe/series/strftime.rs
@@ -61,7 +61,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         .date64()
         .map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
 
-    let res = casted.strftime(fmt.item.as_str()).into_series();
+    let res = casted.strftime(&fmt.item).into_series();
     let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
     Ok(OutputStream::one(df.into_value(df_tag)))
 }
diff --git a/crates/nu-command/src/commands/dataframe/to_csv.rs b/crates/nu-command/src/commands/dataframe/to_csv.rs
index c9409eed1..e62d766df 100644
--- a/crates/nu-command/src/commands/dataframe/to_csv.rs
+++ b/crates/nu-command/src/commands/dataframe/to_csv.rs
@@ -64,14 +64,10 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let delimiter: Option<Tagged<String>> = args.get_flag("delimiter")?;
     let no_header: bool = args.has_flag("no_header");
 
-    let (mut df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let mut file = File::create(&file_name.item).map_err(|e| {
-        ShellError::labeled_error(
-            "Error with file name",
-            format!("{}", e),
-            &file_name.tag.span,
-        )
+        ShellError::labeled_error("Error with file name", e.to_string(), &file_name.tag.span)
     })?;
 
     let writer = CsvWriter::new(&mut file);
@@ -103,7 +99,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     };
 
     writer
-        .finish(df.as_mut())
+        .finish(df.as_ref())
         .map_err(|e| parse_polars_error::<&str>(&e, &file_name.tag.span, None))?;
 
     let tagged_value = Value {
diff --git a/crates/nu-command/src/commands/dataframe/to_parquet.rs b/crates/nu-command/src/commands/dataframe/to_parquet.rs
index e1cf1787b..87bb4b925 100644
--- a/crates/nu-command/src/commands/dataframe/to_parquet.rs
+++ b/crates/nu-command/src/commands/dataframe/to_parquet.rs
@@ -48,18 +48,14 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
     let file_name: Tagged<PathBuf> = args.req(0)?;
 
-    let (mut df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
     let file = File::create(&file_name.item).map_err(|e| {
-        ShellError::labeled_error(
-            "Error with file name",
-            format!("{}", e),
-            &file_name.tag.span,
-        )
+        ShellError::labeled_error("Error with file name", e.to_string(), &file_name.tag.span)
     })?;
 
     ParquetWriter::new(file)
-        .finish(df.as_mut())
+        .finish(df.as_ref())
         .map_err(|e| parse_polars_error::<&str>(&e, &file_name.tag.span, None))?;
 
     let tagged_value = Value {
diff --git a/crates/nu-command/src/commands/dataframe/utils.rs b/crates/nu-command/src/commands/dataframe/utils.rs
index 2a17146eb..174710ae6 100644
--- a/crates/nu-command/src/commands/dataframe/utils.rs
+++ b/crates/nu-command/src/commands/dataframe/utils.rs
@@ -46,30 +46,32 @@ pub(crate) fn parse_polars_error<T: AsRef<str>>(
     span: &Span,
     secondary: Option<T>,
 ) -> ShellError {
-    let (msg, label) = match e {
-        PolarsError::PolarsArrowError(_) => ("PolarsArrow Error", format!("{}", e)),
-        PolarsError::ArrowError(_) => ("Arrow Error", format!("{}", e)),
-        PolarsError::InvalidOperation(_) => ("Invalid Operation", format!("{}", e)),
-        PolarsError::DataTypeMisMatch(_) => ("Data Type Mismatch", format!("{}", e)),
-        PolarsError::NotFound(_) => ("Not Found", format!("{}", e)),
-        PolarsError::ShapeMisMatch(_) => ("Shape Mismatch", format!("{}", e)),
-        PolarsError::Other(_) => ("Other", format!("{}", e)),
-        PolarsError::OutOfBounds(_) => ("Out Of Bounds", format!("{}", e)),
-        PolarsError::NoSlice => ("No Slice", format!("{}", e)),
-        PolarsError::NoData(_) => ("No Data", format!("{}", e)),
-        PolarsError::ValueError(_) => ("Value Error", format!("{}", e)),
-        PolarsError::MemoryNotAligned => ("Memory Not Aligned", format!("{}", e)),
-        PolarsError::ParquetError(_) => ("Parquet Error", format!("{}", e)),
-        PolarsError::RandError(_) => ("Rand Error", format!("{}", e)),
-        PolarsError::HasNullValues(_) => ("Has Null Values", format!("{}", e)),
-        PolarsError::UnknownSchema(_) => ("Unknown Schema", format!("{}", e)),
-        PolarsError::Various(_) => ("Various", format!("{}", e)),
-        PolarsError::Io(_) => ("Io Error", format!("{}", e)),
-        PolarsError::Regex(_) => ("Regex Error", format!("{}", e)),
-        PolarsError::Duplicate(_) => ("Duplicate Error", format!("{}", e)),
-        PolarsError::ImplementationError => ("Implementation Error", format!("{}", e)),
+    let msg = match e {
+        PolarsError::PolarsArrowError(_) => "PolarsArrow Error",
+        PolarsError::ArrowError(_) => "Arrow Error",
+        PolarsError::InvalidOperation(_) => "Invalid Operation",
+        PolarsError::DataTypeMisMatch(_) => "Data Type Mismatch",
+        PolarsError::NotFound(_) => "Not Found",
+        PolarsError::ShapeMisMatch(_) => "Shape Mismatch",
+        PolarsError::Other(_) => "Other",
+        PolarsError::OutOfBounds(_) => "Out Of Bounds",
+        PolarsError::NoSlice => "No Slice",
+        PolarsError::NoData(_) => "No Data",
+        PolarsError::ValueError(_) => "Value Error",
+        PolarsError::MemoryNotAligned => "Memory Not Aligned",
+        PolarsError::ParquetError(_) => "Parquet Error",
+        PolarsError::RandError(_) => "Rand Error",
+        PolarsError::HasNullValues(_) => "Has Null Values",
+        PolarsError::UnknownSchema(_) => "Unknown Schema",
+        PolarsError::Various(_) => "Various",
+        PolarsError::Io(_) => "Io Error",
+        PolarsError::Regex(_) => "Regex Error",
+        PolarsError::Duplicate(_) => "Duplicate Error",
+        PolarsError::ImplementationError => "Implementation Error",
     };
 
+    let label = e.to_string();
+
     match secondary {
         None => ShellError::labeled_error(msg, label, span),
         Some(s) => ShellError::labeled_error_with_secondary(msg, label, span, s.as_ref(), span),
diff --git a/crates/nu-command/src/commands/dataframe/with_column.rs b/crates/nu-command/src/commands/dataframe/with_column.rs
index 3b6d5e8a8..da2225add 100644
--- a/crates/nu-command/src/commands/dataframe/with_column.rs
+++ b/crates/nu-command/src/commands/dataframe/with_column.rs
@@ -82,7 +82,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     let mut series = df.as_series(&value.tag.span)?;
 
-    let series = series.rename(name.item.as_ref()).clone();
+    let series = series.rename(&name.item).clone();
 
     let (mut df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
 
diff --git a/crates/nu-command/src/commands/env/autoenv_untrust.rs b/crates/nu-command/src/commands/env/autoenv_untrust.rs
index a4e2098d6..61e144805 100644
--- a/crates/nu-command/src/commands/env/autoenv_untrust.rs
+++ b/crates/nu-command/src/commands/env/autoenv_untrust.rs
@@ -61,7 +61,7 @@ impl WholeStreamCommand for AutoenvUntrust {
         let mut doc = String::new();
         file.read_to_string(&mut doc)?;
 
-        let mut allowed: Trusted = toml::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
+        let mut allowed: Trusted = toml::from_str(&doc).unwrap_or_else(|_| Trusted::new());
 
         let file_to_untrust = file_to_untrust.to_string_lossy().to_string();
 
diff --git a/crates/nu-command/src/commands/filesystem/open.rs b/crates/nu-command/src/commands/filesystem/open.rs
index a427061dc..d8ddbcfb2 100644
--- a/crates/nu-command/src/commands/filesystem/open.rs
+++ b/crates/nu-command/src/commands/filesystem/open.rs
@@ -173,9 +173,9 @@ fn open(args: CommandArgs) -> Result<ActionStream, ShellError> {
             Ok(StringOrBinary::String(s)) => {
                 ReturnSuccess::value(UntaggedValue::string(s).into_value(file_tag))
             }
-            Ok(StringOrBinary::Binary(b)) => ReturnSuccess::value(
-                UntaggedValue::binary(b.into_iter().collect()).into_value(file_tag),
-            ),
+            Ok(StringOrBinary::Binary(b)) => {
+                ReturnSuccess::value(UntaggedValue::binary(b).into_value(file_tag))
+            }
             Err(se) => Err(se),
         }
     });
diff --git a/crates/nu-command/src/commands/filesystem/save.rs b/crates/nu-command/src/commands/filesystem/save.rs
index f8f0f9538..5f342683d 100644
--- a/crates/nu-command/src/commands/filesystem/save.rs
+++ b/crates/nu-command/src/commands/filesystem/save.rs
@@ -241,7 +241,7 @@ fn string_from(input: &[Value]) -> String {
 
     if !input.is_empty() {
         let mut first = true;
-        for i in input.iter() {
+        for i in input {
             if !first {
                 save_data.push('\n');
             } else {
diff --git a/crates/nu-command/src/commands/filesystem/touch.rs b/crates/nu-command/src/commands/filesystem/touch.rs
index 200fca265..6b2907f48 100644
--- a/crates/nu-command/src/commands/filesystem/touch.rs
+++ b/crates/nu-command/src/commands/filesystem/touch.rs
@@ -48,7 +48,7 @@ fn touch(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let target: Tagged<PathBuf> = args.req(0)?;
     let rest: Vec<Tagged<PathBuf>> = args.rest(1)?;
 
-    for item in vec![target].into_iter().chain(rest.into_iter()) {
+    for item in vec![target].into_iter().chain(rest) {
         match OpenOptions::new().write(true).create(true).open(&item) {
             Ok(_) => continue,
             Err(err) => {
diff --git a/crates/nu-command/src/commands/filters/append.rs b/crates/nu-command/src/commands/filters/append.rs
index ce937acd5..f43a4f565 100644
--- a/crates/nu-command/src/commands/filters/append.rs
+++ b/crates/nu-command/src/commands/filters/append.rs
@@ -45,7 +45,7 @@ impl WholeStreamCommand for Command {
 
         Ok(prepend
             .into_iter()
-            .chain(args.input.into_iter().chain(vec![value]))
+            .chain(args.input.into_iter().chain([value]))
             .into_output_stream())
     }
 
diff --git a/crates/nu-command/src/commands/filters/each/command.rs b/crates/nu-command/src/commands/filters/each/command.rs
index 9e7a97bcc..036168303 100644
--- a/crates/nu-command/src/commands/filters/each/command.rs
+++ b/crates/nu-command/src/commands/filters/each/command.rs
@@ -96,7 +96,7 @@ pub fn process_row(
 
     let result = run_block(
         &captured_block.block,
-        &*context,
+        &context,
         input_stream,
         external_redirection,
     );
@@ -127,7 +127,7 @@ fn each(args: CommandArgs) -> Result<OutputStream, ShellError> {
         Ok(args
             .input
             .enumerate()
-            .map(move |input| {
+            .flat_map(move |input| {
                 let block = block.clone();
                 let context = context.clone();
                 let row = make_indexed_item(input.0, input.1);
@@ -137,12 +137,11 @@ fn each(args: CommandArgs) -> Result<OutputStream, ShellError> {
                     Err(e) => OutputStream::one(Value::error(e)),
                 }
             })
-            .flatten()
             .into_output_stream())
     } else {
         Ok(args
             .input
-            .map(move |input| {
+            .flat_map(move |input| {
                 let block = block.clone();
                 let context = context.clone();
 
@@ -151,7 +150,6 @@ fn each(args: CommandArgs) -> Result<OutputStream, ShellError> {
                     Err(e) => OutputStream::one(Value::error(e)),
                 }
             })
-            .flatten()
             .into_output_stream())
     }
 }
diff --git a/crates/nu-command/src/commands/filters/each/window.rs b/crates/nu-command/src/commands/filters/each/window.rs
index 6c13983a1..2b7efbd51 100644
--- a/crates/nu-command/src/commands/filters/each/window.rs
+++ b/crates/nu-command/src/commands/filters/each/window.rs
@@ -64,7 +64,7 @@ impl WholeStreamCommand for EachWindow {
         Ok(args
             .input
             .enumerate()
-            .map(move |(i, input)| {
+            .flat_map(move |(i, input)| {
                 // This would probably be more efficient if `last` was a VecDeque
                 // But we can't have that because it needs to be put into a Table
                 window.remove(0);
@@ -86,7 +86,6 @@ impl WholeStreamCommand for EachWindow {
                 }
             })
             .flatten()
-            .flatten()
             .map(Ok)
             .into_input_stream())
     }
diff --git a/crates/nu-command/src/commands/filters/empty.rs b/crates/nu-command/src/commands/filters/empty.rs
index e49499c6d..cad66fc10 100644
--- a/crates/nu-command/src/commands/filters/empty.rs
+++ b/crates/nu-command/src/commands/filters/empty.rs
@@ -140,7 +140,7 @@ fn process_row(
 
         let stream = run_block(
             &default_block.block,
-            &*context,
+            context,
             input_stream,
             ExternalRedirection::Stdout,
         );
diff --git a/crates/nu-command/src/commands/filters/flatten.rs b/crates/nu-command/src/commands/filters/flatten.rs
index d18342bd9..fef4b5153 100644
--- a/crates/nu-command/src/commands/filters/flatten.rs
+++ b/crates/nu-command/src/commands/filters/flatten.rs
@@ -56,8 +56,7 @@ fn flatten(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let input = args.input;
 
     Ok(input
-        .map(move |item| flat_value(&columns, &item, &tag).into_iter())
-        .flatten()
+        .flat_map(move |item| flat_value(&columns, &item, &tag))
         .into_action_stream())
 }
 
@@ -96,7 +95,7 @@ fn flat_value(
                         continue;
                     }
 
-                    for (k, v) in mapa.into_iter() {
+                    for (k, v) in mapa {
                         if out.contains_key(k) {
                             out.insert_value(format!("{}_{}", column, k), v.clone());
                         } else {
@@ -159,7 +158,7 @@ fn flat_value(
             let mut expanded = vec![];
 
             if let Some(TableInside::Entries(column, _, entries)) = a_table {
-                for entry in entries.into_iter() {
+                for entry in entries {
                     let mut base = out.clone();
                     base.insert_value(column, entry.clone());
                     expanded.push(base.into_value());
@@ -170,7 +169,7 @@ fn flat_value(
 
             expanded
         } else if item.is_table() {
-            item.table_entries().map(Clone::clone).collect()
+            item.table_entries().cloned().collect()
         } else {
             vec![item.clone()]
         }
diff --git a/crates/nu-command/src/commands/filters/get.rs b/crates/nu-command/src/commands/filters/get.rs
index bb282cb33..3926bcbb6 100644
--- a/crates/nu-command/src/commands/filters/get.rs
+++ b/crates/nu-command/src/commands/filters/get.rs
@@ -65,14 +65,12 @@ pub fn get(args: CommandArgs) -> Result<ActionStream, ShellError> {
     } else {
         trace!("get {:?}", column_paths);
         let output_stream = input
-            .map(move |item| {
+            .flat_map(move |item| {
                 column_paths
                     .iter()
-                    .map(move |path| get_output(&item, path))
-                    .flatten()
+                    .flat_map(move |path| get_output(&item, path))
                     .collect::<Vec<_>>()
             })
-            .flatten()
             .into_action_stream();
         Ok(output_stream)
     }
diff --git a/crates/nu-command/src/commands/filters/group_by.rs b/crates/nu-command/src/commands/filters/group_by.rs
index 81cdff8ef..cd9841b4e 100644
--- a/crates/nu-command/src/commands/filters/group_by.rs
+++ b/crates/nu-command/src/commands/filters/group_by.rs
@@ -140,7 +140,7 @@ pub fn group_by(args: CommandArgs) -> Result<OutputStream, ShellError> {
             let block = Arc::new(block_given);
             let error_key = "error";
 
-            for value in values.iter() {
+            for value in &values {
                 let run = block.clone();
                 let context = context.clone();
 
diff --git a/crates/nu-command/src/commands/filters/insert.rs b/crates/nu-command/src/commands/filters/insert.rs
index 83e268895..2cbcef591 100644
--- a/crates/nu-command/src/commands/filters/insert.rs
+++ b/crates/nu-command/src/commands/filters/insert.rs
@@ -80,7 +80,7 @@ fn process_row(
 
             let result = run_block(
                 &block.block,
-                &*context,
+                &context,
                 input_stream,
                 ExternalRedirection::Stdout,
             );
@@ -162,7 +162,7 @@ fn insert(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let column = Arc::new(column);
 
     Ok(input
-        .map(move |input| {
+        .flat_map(move |input| {
             let context = context.clone();
             let value = value.clone();
             let column = column.clone();
@@ -172,6 +172,5 @@ fn insert(args: CommandArgs) -> Result<ActionStream, ShellError> {
                 Err(e) => ActionStream::one(Err(e)),
             }
         })
-        .flatten()
         .into_action_stream())
 }
diff --git a/crates/nu-command/src/commands/filters/keep/until.rs b/crates/nu-command/src/commands/filters/keep/until.rs
index 143ca668f..e5e9d3aa9 100644
--- a/crates/nu-command/src/commands/filters/keep/until.rs
+++ b/crates/nu-command/src/commands/filters/keep/until.rs
@@ -74,7 +74,7 @@ impl WholeStreamCommand for SubCommand {
                     ctx.scope.add_var(arg.name(), item.clone());
                 }
 
-                let result = evaluate_baseline_expr(&*condition, &*ctx);
+                let result = evaluate_baseline_expr(&condition, &ctx);
                 ctx.scope.exit_scope();
 
                 !matches!(result, Ok(ref v) if v.is_true())
diff --git a/crates/nu-command/src/commands/filters/keep/while_.rs b/crates/nu-command/src/commands/filters/keep/while_.rs
index 6cdcda2c8..ad4f98def 100644
--- a/crates/nu-command/src/commands/filters/keep/while_.rs
+++ b/crates/nu-command/src/commands/filters/keep/while_.rs
@@ -76,7 +76,7 @@ impl WholeStreamCommand for SubCommand {
                 }
                 trace!("ITEM = {:?}", item);
 
-                let result = evaluate_baseline_expr(&*condition, &*ctx);
+                let result = evaluate_baseline_expr(&condition, &ctx);
                 ctx.scope.exit_scope();
                 trace!("RESULT = {:?}", result);
 
diff --git a/crates/nu-command/src/commands/filters/move_.rs b/crates/nu-command/src/commands/filters/move_.rs
index 176232894..a7daf5423 100644
--- a/crates/nu-command/src/commands/filters/move_.rs
+++ b/crates/nu-command/src/commands/filters/move_.rs
@@ -242,7 +242,7 @@ fn move_after(table: &Value, columns: &[String], from: &ColumnPath) -> Result<Va
     let mut insert = false;
     let mut inserted = false;
 
-    for name in columns_moved.into_iter() {
+    for name in columns_moved {
         if let Some(name) = name {
             reordered_columns.push(Some(name.clone()));
 
@@ -291,7 +291,7 @@ fn move_before(table: &Value, columns: &[String], from: &ColumnPath) -> Result<V
     let mut reordered_columns = vec![];
     let mut inserted = false;
 
-    for name in columns_moved.into_iter() {
+    for name in columns_moved {
         if let Some(name) = name {
             if !inserted && name == from {
                 for column in columns {
diff --git a/crates/nu-command/src/commands/filters/reduce.rs b/crates/nu-command/src/commands/filters/reduce.rs
index 31ea62250..bacb0601b 100644
--- a/crates/nu-command/src/commands/filters/reduce.rs
+++ b/crates/nu-command/src/commands/filters/reduce.rs
@@ -163,7 +163,7 @@ fn reduce(args: CommandArgs) -> Result<ActionStream, ShellError> {
 
                 context.scope.enter_scope();
                 context.scope.add_var("$acc", f);
-                let result = process_row(block, &*context, row);
+                let result = process_row(block, &context, row);
                 context.scope.exit_scope();
 
                 // we make sure that result is an indexed item
@@ -201,7 +201,7 @@ fn reduce(args: CommandArgs) -> Result<ActionStream, ShellError> {
 
                 context.scope.enter_scope();
                 context.scope.add_var("$acc", f);
-                let result = process_row(block, &*context, row);
+                let result = process_row(block, &context, row);
                 context.scope.exit_scope();
                 result
             })?
diff --git a/crates/nu-command/src/commands/filters/roll/column.rs b/crates/nu-command/src/commands/filters/roll/column.rs
index ddec75e3a..6650babd0 100644
--- a/crates/nu-command/src/commands/filters/roll/column.rs
+++ b/crates/nu-command/src/commands/filters/roll/column.rs
@@ -59,14 +59,12 @@ pub fn roll(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Ok(args
         .input
-        .map(move |value| {
+        .flat_map(move |value| {
             let tag = value.tag();
 
             roll_by(value, &options)
                 .unwrap_or_else(|| vec![UntaggedValue::nothing().into_value(tag)])
-                .into_iter()
         })
-        .flatten()
         .into_output_stream())
 }
 
@@ -84,8 +82,7 @@ fn roll_by(value: Value, options: &Arguments) -> Option<Vec<Value>> {
             let values_rotated = rotate(
                 value
                     .row_entries()
-                    .map(|(_, value)| value)
-                    .map(Clone::clone)
+                    .map(|(_, value)| value.clone())
                     .collect::<Vec<_>>(),
                 &options.by,
                 direction,
@@ -94,7 +91,7 @@ fn roll_by(value: Value, options: &Arguments) -> Option<Vec<Value>> {
             if let Some(ref values) = values_rotated {
                 let mut out = TaggedDictBuilder::new(&tag);
 
-                for (k, v) in columns.iter().zip(values.iter()) {
+                for (k, v) in columns.iter().zip(values) {
                     out.insert_value(k, v.clone());
                 }
 
@@ -104,7 +101,7 @@ fn roll_by(value: Value, options: &Arguments) -> Option<Vec<Value>> {
         None
     } else if value.is_table() {
         rotate(
-            value.table_entries().map(Clone::clone).collect(),
+            value.table_entries().cloned().collect(),
             &options.by,
             direction,
         )
diff --git a/crates/nu-command/src/commands/filters/skip/until.rs b/crates/nu-command/src/commands/filters/skip/until.rs
index 12285f0b9..33a347940 100644
--- a/crates/nu-command/src/commands/filters/skip/until.rs
+++ b/crates/nu-command/src/commands/filters/skip/until.rs
@@ -76,7 +76,7 @@ impl WholeStreamCommand for SubCommand {
                 }
                 trace!("ITEM = {:?}", item);
 
-                let result = evaluate_baseline_expr(&*condition, &*ctx);
+                let result = evaluate_baseline_expr(&condition, &ctx);
                 ctx.scope.exit_scope();
                 trace!("RESULT = {:?}", result);
 
diff --git a/crates/nu-command/src/commands/filters/skip/while_.rs b/crates/nu-command/src/commands/filters/skip/while_.rs
index 0fc89a8e0..ed8b35529 100644
--- a/crates/nu-command/src/commands/filters/skip/while_.rs
+++ b/crates/nu-command/src/commands/filters/skip/while_.rs
@@ -77,7 +77,7 @@ impl WholeStreamCommand for SubCommand {
                 }
                 trace!("ITEM = {:?}", item);
 
-                let result = evaluate_baseline_expr(&*condition, &*ctx);
+                let result = evaluate_baseline_expr(&condition, &ctx);
                 ctx.scope.exit_scope();
                 trace!("RESULT = {:?}", result);
 
diff --git a/crates/nu-command/src/commands/filters/sort_by.rs b/crates/nu-command/src/commands/filters/sort_by.rs
index 4201db98d..30b6869c4 100644
--- a/crates/nu-command/src/commands/filters/sort_by.rs
+++ b/crates/nu-command/src/commands/filters/sort_by.rs
@@ -118,7 +118,7 @@ fn sort_by(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
         vec.reverse()
     }
 
-    Ok((vec.into_iter()).into_output_stream())
+    Ok(vec.into_iter().into_output_stream())
 }
 
 pub fn sort(
@@ -137,7 +137,7 @@ pub fn sort(
         ));
     }
 
-    for sort_arg in keys.iter() {
+    for sort_arg in keys {
         let match_test = &vec[0].get_data_by_key(sort_arg.borrow_spanned());
         if match_test.is_none() {
             return Err(ShellError::labeled_error(
diff --git a/crates/nu-command/src/commands/filters/update.rs b/crates/nu-command/src/commands/filters/update.rs
index 37612e9af..6a63beef5 100644
--- a/crates/nu-command/src/commands/filters/update.rs
+++ b/crates/nu-command/src/commands/filters/update.rs
@@ -66,7 +66,6 @@ fn process_row(
     field: Arc<ColumnPath>,
     tag: Arc<Tag>,
 ) -> Result<ActionStream, ShellError> {
-    let tag = &*tag;
     let replacement = Arc::make_mut(&mut replacement);
 
     Ok(match replacement {
@@ -86,7 +85,7 @@ fn process_row(
 
             let result = run_block(
                 &captured_block.block,
-                &*context,
+                &context,
                 input_stream,
                 ExternalRedirection::Stdout,
             );
@@ -184,7 +183,7 @@ fn update(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let field = Arc::new(field);
 
     Ok(input
-        .map(move |input| {
+        .flat_map(move |input| {
             let tag = name_tag.clone();
             let context = context.clone();
             let replacement = replacement.clone();
@@ -195,6 +194,5 @@ fn update(args: CommandArgs) -> Result<ActionStream, ShellError> {
                 Err(e) => ActionStream::one(Err(e)),
             }
         })
-        .flatten()
         .into_action_stream())
 }
diff --git a/crates/nu-command/src/commands/formats/from/delimited.rs b/crates/nu-command/src/commands/formats/from/delimited.rs
index be840bbb7..28b5df27e 100644
--- a/crates/nu-command/src/commands/formats/from/delimited.rs
+++ b/crates/nu-command/src/commands/formats/from/delimited.rs
@@ -27,7 +27,7 @@ fn from_delimited_string_to_value(
     let mut rows = vec![];
     for row in reader.records() {
         let mut tagged_row = TaggedDictBuilder::new(&tag);
-        for (value, header) in row?.iter().zip(headers.iter()) {
+        for (value, header) in row?.iter().zip(&headers) {
             if let Ok(i) = value.parse::<i64>() {
                 tagged_row.insert_value(header, UntaggedValue::int(i).into_value(&tag))
             } else if let Ok(f) = value.parse::<f64>() {
diff --git a/crates/nu-command/src/commands/formats/from/eml.rs b/crates/nu-command/src/commands/formats/from/eml.rs
index cd2de742f..68bbee84c 100644
--- a/crates/nu-command/src/commands/formats/from/eml.rs
+++ b/crates/nu-command/src/commands/formats/from/eml.rs
@@ -100,7 +100,7 @@ fn from_eml(args: CommandArgs) -> Result<OutputStream, ShellError> {
         dict.insert_untagged("To", headerfieldvalue_to_value(&tag, &to));
     }
 
-    for HeaderField { name, value } in eml.headers.iter() {
+    for HeaderField { name, value } in &eml.headers {
         dict.insert_untagged(name, headerfieldvalue_to_value(&tag, value));
     }
 
diff --git a/crates/nu-command/src/commands/formats/from/yaml.rs b/crates/nu-command/src/commands/formats/from/yaml.rs
index 2daa0345f..b371074a1 100644
--- a/crates/nu-command/src/commands/formats/from/yaml.rs
+++ b/crates/nu-command/src/commands/formats/from/yaml.rs
@@ -75,7 +75,7 @@ fn convert_yaml_value_to_nu_value(
         serde_yaml::Value::Mapping(t) => {
             let mut collected = TaggedDictBuilder::new(&tag);
 
-            for (k, v) in t.iter() {
+            for (k, v) in t {
                 // A ShellError that we re-use multiple times in the Mapping scenario
                 let err_unexpected_map = ShellError::labeled_error(
                     format!("Unexpected YAML:\nKey: {:?}\nValue: {:?}", k, v),
@@ -202,7 +202,7 @@ mod tests {
                 expected: Ok(row!["value".to_owned() => string("{{ something }}")]),
             },
         ];
-        for tc in tt.into_iter() {
+        for tc in tt {
             let actual = from_yaml_string_to_value(tc.input.to_owned(), Tag::default());
             if actual.is_err() {
                 assert!(
diff --git a/crates/nu-command/src/commands/formats/to/delimited.rs b/crates/nu-command/src/commands/formats/to/delimited.rs
index bccae9aab..bba16a308 100644
--- a/crates/nu-command/src/commands/formats/to/delimited.rs
+++ b/crates/nu-command/src/commands/formats/to/delimited.rs
@@ -20,7 +20,7 @@ fn from_value_to_delimited_string(
             let mut fields: VecDeque<String> = VecDeque::new();
             let mut values: VecDeque<String> = VecDeque::new();
 
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 fields.push_back(k.clone());
 
                 values.push_back(to_string_tagged_value(v)?);
@@ -130,12 +130,14 @@ pub fn clone_tagged_value(v: &Value) -> Value {
 // NOTE: could this be useful more widely and implemented on Value ?
 fn to_string_tagged_value(v: &Value) -> Result<String, ShellError> {
     match &v.value {
-        UntaggedValue::Primitive(Primitive::String(_))
-        | UntaggedValue::Primitive(Primitive::Filesize(_))
-        | UntaggedValue::Primitive(Primitive::Boolean(_))
-        | UntaggedValue::Primitive(Primitive::Decimal(_))
-        | UntaggedValue::Primitive(Primitive::FilePath(_))
-        | UntaggedValue::Primitive(Primitive::Int(_)) => as_string(v),
+        UntaggedValue::Primitive(
+            Primitive::String(_)
+            | Primitive::Filesize(_)
+            | Primitive::Boolean(_)
+            | Primitive::Decimal(_)
+            | Primitive::FilePath(_)
+            | Primitive::Int(_),
+        ) => as_string(v),
         UntaggedValue::Primitive(Primitive::Date(d)) => Ok(d.to_string()),
         UntaggedValue::Primitive(Primitive::Nothing) => Ok(String::new()),
         UntaggedValue::Table(_) => Ok(String::from("[Table]")),
@@ -153,7 +155,7 @@ fn merge_descriptors(values: &[Value]) -> Vec<Spanned<String>> {
     let mut seen: IndexSet<String> = indexset! {};
     for value in values {
         for desc in value.data_descriptors() {
-            if !seen.contains(&desc[..]) {
+            if !seen.contains(&desc) {
                 seen.insert(desc.clone());
                 ret.push(desc.spanned(value.tag.span));
             }
diff --git a/crates/nu-command/src/commands/formats/to/html.rs b/crates/nu-command/src/commands/formats/to/html.rs
index 85e419ce1..991f17e69 100644
--- a/crates/nu-command/src/commands/formats/to/html.rs
+++ b/crates/nu-command/src/commands/formats/to/html.rs
@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::error::Error;
+use std::fmt::Write;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct HtmlThemes {
@@ -124,8 +125,8 @@ fn get_theme_from_asset_file(
     theme_tag: &Tag,
 ) -> Result<HashMap<&'static str, String>, ShellError> {
     let theme_name = match theme {
-        Some(s) => s.to_string(),
-        None => "default".to_string(), // There is no theme named "default" so this will be HtmlTheme::default(), which is "nu_default".
+        Some(s) => s.as_str(),
+        None => "default", // There is no theme named "default" so this will be HtmlTheme::default(), which is "nu_default".
     };
 
     // 228 themes come from
@@ -143,7 +144,7 @@ fn get_theme_from_asset_file(
     let th = asset
         .themes
         .iter()
-        .find(|&n| n.name.to_lowercase() == *theme_name.to_lowercase().as_str()); // case insensitive search
+        .find(|&n| n.name.to_lowercase() == theme_name.to_lowercase()); // case insensitive search
 
     // If no theme is found by the name provided, ensure we return the default theme
     let default_theme = HtmlTheme::default();
@@ -248,11 +249,7 @@ fn get_list_of_theme_names() -> Vec<String> {
         _ => HtmlThemes::default(),
     };
 
-    let theme_names: Vec<String> = html_themes
-        .themes
-        .iter()
-        .map(|n| n.name[..].to_string())
-        .collect();
+    let theme_names: Vec<String> = html_themes.themes.iter().map(|n| n.name.clone()).collect();
 
     theme_names
 }
@@ -278,8 +275,8 @@ fn to_html(args: CommandArgs) -> Result<OutputStream, ShellError> {
         let theme_names = get_list_of_theme_names();
 
         // Put that list into the output string
-        for s in theme_names.iter() {
-            output_string.push_str(&format!("{}\n", s));
+        for s in &theme_names {
+            writeln!(&mut output_string, "{}", s).unwrap();
         }
 
         output_string.push_str("\nScreenshots of themes can be found here:\n");
@@ -304,7 +301,8 @@ fn to_html(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
         // change the color of the page
         if !partial {
-            output_string.push_str(&format!(
+            write!(
+                &mut output_string,
                 r"<html><style>body {{ background-color:{};color:{}; }}</style><body>",
                 color_hm
                     .get("background")
@@ -312,9 +310,11 @@ fn to_html(args: CommandArgs) -> Result<OutputStream, ShellError> {
                 color_hm
                     .get("foreground")
                     .expect("Error getting foreground color")
-            ));
+            )
+            .unwrap();
         } else {
-            output_string.push_str(&format!(
+            write!(
+                &mut output_string,
                 "<div style=\"background-color:{};color:{};\">",
                 color_hm
                     .get("background")
@@ -322,7 +322,8 @@ fn to_html(args: CommandArgs) -> Result<OutputStream, ShellError> {
                 color_hm
                     .get("foreground")
                     .expect("Error getting foreground color")
-            ));
+            )
+            .unwrap();
         }
 
         let inner_value = match input.len() {
diff --git a/crates/nu-command/src/commands/formats/to/json.rs b/crates/nu-command/src/commands/formats/to/json.rs
index f63288e99..43f769ec8 100644
--- a/crates/nu-command/src/commands/formats/to/json.rs
+++ b/crates/nu-command/src/commands/formats/to/json.rs
@@ -134,7 +134,7 @@ pub fn value_to_json_value(v: &Value) -> Result<serde_json::Value, ShellError> {
         ),
         UntaggedValue::Row(o) => {
             let mut m = serde_json::Map::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(k.clone(), value_to_json_value(v)?);
             }
             serde_json::Value::Object(m)
@@ -184,9 +184,7 @@ fn to_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
                             if let Ok(pretty_u64) = pretty_value.as_u64() {
                                 if let Ok(serde_json_value) =
-                                    serde_json::from_str::<serde_json::Value>(
-                                        serde_json_string.as_str(),
-                                    )
+                                    serde_json::from_str::<serde_json::Value>(&serde_json_string)
                                 {
                                     let indentation_string = " ".repeat(pretty_u64 as usize);
                                     let serde_formatter =
diff --git a/crates/nu-command/src/commands/formats/to/md.rs b/crates/nu-command/src/commands/formats/to/md.rs
index 49444b76a..f29fe145d 100644
--- a/crates/nu-command/src/commands/formats/to/md.rs
+++ b/crates/nu-command/src/commands/formats/to/md.rs
@@ -236,7 +236,7 @@ fn get_output_string(
                 ));
                 output_string.push(' ');
             } else {
-                output_string.push_str(headers[i].as_str());
+                output_string.push_str(&headers[i]);
             }
 
             output_string.push('|');
@@ -275,7 +275,7 @@ fn get_output_string(
                 output_string.push_str(&get_padded_string(row[i].clone(), column_widths[i], ' '));
                 output_string.push(' ');
             } else {
-                output_string.push_str(row[i].as_str());
+                output_string.push_str(&row[i]);
             }
 
             if !headers.is_empty() {
diff --git a/crates/nu-command/src/commands/formats/to/toml.rs b/crates/nu-command/src/commands/formats/to/toml.rs
index 6423af75d..1610e35c6 100644
--- a/crates/nu-command/src/commands/formats/to/toml.rs
+++ b/crates/nu-command/src/commands/formats/to/toml.rs
@@ -83,7 +83,7 @@ fn helper(v: &Value) -> Result<toml::Value, ShellError> {
         }
         UntaggedValue::Row(o) => {
             let mut m = toml::map::Map::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(k.clone(), helper(v)?);
             }
             toml::Value::Table(m)
@@ -97,7 +97,7 @@ pub fn value_to_toml_value(v: &Value) -> Result<toml::Value, ShellError> {
     match &v.value {
         UntaggedValue::Row(o) => {
             let mut m = toml::map::Map::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(k.clone(), helper(v)?);
             }
             Ok(toml::Value::Table(m))
diff --git a/crates/nu-command/src/commands/formats/to/xml.rs b/crates/nu-command/src/commands/formats/to/xml.rs
index adab2e06d..28fe8d0c2 100644
--- a/crates/nu-command/src/commands/formats/to/xml.rs
+++ b/crates/nu-command/src/commands/formats/to/xml.rs
@@ -37,7 +37,7 @@ pub fn add_attributes<'a>(
     element: &mut quick_xml::events::BytesStart<'a>,
     attributes: &'a IndexMap<String, String>,
 ) {
-    for (k, v) in attributes.iter() {
+    for (k, v) in attributes {
         element.push_attribute((k.as_str(), v.as_str()));
     }
 }
@@ -47,7 +47,7 @@ pub fn get_attributes(row: &Value) -> Option<IndexMap<String, String>> {
         if let Some(v) = r.entries.get("attributes") {
             if let UntaggedValue::Row(a) = &v.value {
                 let mut h = IndexMap::new();
-                for (k, v) in a.entries.iter() {
+                for (k, v) in &a.entries {
                     h.insert(k.clone(), v.convert_to_string());
                 }
                 return Some(h);
@@ -84,7 +84,7 @@ pub fn write_xml_events<W: Write>(
 ) -> Result<(), ShellError> {
     match &current.value {
         UntaggedValue::Row(o) => {
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 let mut e = BytesStart::owned(k.as_bytes(), k.len());
                 if !is_xml_row(v) {
                     return Err(ShellError::labeled_error(
diff --git a/crates/nu-command/src/commands/formats/to/yaml.rs b/crates/nu-command/src/commands/formats/to/yaml.rs
index c6a23a4d2..44f65d29f 100644
--- a/crates/nu-command/src/commands/formats/to/yaml.rs
+++ b/crates/nu-command/src/commands/formats/to/yaml.rs
@@ -65,7 +65,7 @@ pub fn value_to_yaml_value(v: &Value) -> Result<serde_yaml::Value, ShellError> {
         UntaggedValue::Primitive(Primitive::ColumnPath(path)) => {
             let mut out = vec![];
 
-            for member in path.iter() {
+            for member in path {
                 match &member.unspanned {
                     UnspannedPathMember::String(string) => {
                         out.push(serde_yaml::Value::String(string.clone()))
@@ -104,7 +104,7 @@ pub fn value_to_yaml_value(v: &Value) -> Result<serde_yaml::Value, ShellError> {
         ),
         UntaggedValue::Row(o) => {
             let mut m = serde_yaml::Mapping::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(
                     serde_yaml::Value::String(k.clone()),
                     value_to_yaml_value(v)?,
diff --git a/crates/nu-command/src/commands/generators/date/to_table.rs b/crates/nu-command/src/commands/generators/date/to_table.rs
index 200894e56..10163451f 100644
--- a/crates/nu-command/src/commands/generators/date/to_table.rs
+++ b/crates/nu-command/src/commands/generators/date/to_table.rs
@@ -77,7 +77,7 @@ fn to_table(args: CommandArgs) -> Result<OutputStream, ShellError> {
                 let tz = dt.offset();
                 indexmap.insert(
                     "timezone".to_string(),
-                    UntaggedValue::string(format!("{}", tz)).into_value(&tag),
+                    UntaggedValue::string(tz.to_string()).into_value(&tag),
                 );
 
                 let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);
diff --git a/crates/nu-command/src/commands/generators/for_in.rs b/crates/nu-command/src/commands/generators/for_in.rs
index 9a3ee52a1..ef455c610 100644
--- a/crates/nu-command/src/commands/generators/for_in.rs
+++ b/crates/nu-command/src/commands/generators/for_in.rs
@@ -90,7 +90,7 @@ pub fn process_row(
 
     let result = run_block(
         &captured_block.block,
-        &*context,
+        context,
         input_stream,
         external_redirection,
     );
@@ -130,7 +130,7 @@ fn for_in(args: CommandArgs) -> Result<OutputStream, ShellError> {
     if numbered {
         Ok(input
             .enumerate()
-            .map(move |input| {
+            .flat_map(move |input| {
                 let row = make_indexed_item(input.0, input.1);
 
                 match process_row(&block, &context, row, &var_name, external_redirection) {
@@ -138,11 +138,10 @@ fn for_in(args: CommandArgs) -> Result<OutputStream, ShellError> {
                     Err(e) => OutputStream::one(Value::error(e)),
                 }
             })
-            .flatten()
             .into_output_stream())
     } else {
         Ok(input
-            .map(move |input| {
+            .flat_map(move |input| {
                 let block = block.clone();
 
                 match process_row(&block, &context, input, &var_name, external_redirection) {
@@ -150,7 +149,6 @@ fn for_in(args: CommandArgs) -> Result<OutputStream, ShellError> {
                     Err(e) => OutputStream::one(Value::error(e)),
                 }
             })
-            .flatten()
             .into_output_stream())
     }
 }
diff --git a/crates/nu-command/src/commands/generators/seq_dates.rs b/crates/nu-command/src/commands/generators/seq_dates.rs
index df4f9122e..184aae7c9 100644
--- a/crates/nu-command/src/commands/generators/seq_dates.rs
+++ b/crates/nu-command/src/commands/generators/seq_dates.rs
@@ -321,7 +321,7 @@ pub fn run_seq_dates(
 
     let mut ret_str = String::from("");
     loop {
-        ret_str.push_str(&format!("{}", next.format(&out_format)));
+        ret_str.push_str(&next.format(&out_format).to_string());
         // TODO: check this value is good
         next += Duration::days(step_size);
 
diff --git a/crates/nu-command/src/commands/math/command.rs b/crates/nu-command/src/commands/math/command.rs
index 30a83e8fc..84604745f 100644
--- a/crates/nu-command/src/commands/math/command.rs
+++ b/crates/nu-command/src/commands/math/command.rs
@@ -169,7 +169,7 @@ mod tests {
             // },
         ];
         let test_tag = Tag::unknown();
-        for tc in tt.iter() {
+        for tc in &tt {
             let tc: &TestCase = tc; // Just for type annotations
             let math_functions: Vec<MathFunction> = vec![
                 average, minimum, maximum, median, mode, stddev, summation, variance,
diff --git a/crates/nu-command/src/commands/math/mode.rs b/crates/nu-command/src/commands/math/mode.rs
index 225514ea9..61c7ea50c 100644
--- a/crates/nu-command/src/commands/math/mode.rs
+++ b/crates/nu-command/src/commands/math/mode.rs
@@ -45,7 +45,7 @@ pub fn mode(values: &[Value], name: &Tag) -> Result<Value, ShellError> {
 
     let mut max_freq = -1;
     let mut modes = Vec::<Value>::new();
-    for (value, frequency) in frequency_map.iter() {
+    for (value, frequency) in &frequency_map {
         match max_freq.cmp(frequency) {
             Ordering::Less => {
                 max_freq = *frequency;
diff --git a/crates/nu-command/src/commands/math/reducers.rs b/crates/nu-command/src/commands/math/reducers.rs
index ab313b046..fdf183172 100644
--- a/crates/nu-command/src/commands/math/reducers.rs
+++ b/crates/nu-command/src/commands/math/reducers.rs
@@ -108,7 +108,7 @@ pub fn max(data: Vec<Value>) -> Result<Value, ShellError> {
         .value
         .clone();
 
-    for value in data.iter() {
+    for value in &data {
         if let Ok(greater_than) = compare_values(Operator::GreaterThan, &value.value, &biggest) {
             if greater_than {
                 biggest = value.value.clone();
@@ -133,7 +133,7 @@ pub fn min(data: Vec<Value>) -> Result<Value, ShellError> {
         .value
         .clone();
 
-    for value in data.iter() {
+    for value in &data {
         if let Ok(greater_than) = compare_values(Operator::LessThan, &value.value, &smallest) {
             if greater_than {
                 smallest = value.value.clone();
diff --git a/crates/nu-command/src/commands/math/stddev.rs b/crates/nu-command/src/commands/math/stddev.rs
index 7048a45ea..02f0ce824 100644
--- a/crates/nu-command/src/commands/math/stddev.rs
+++ b/crates/nu-command/src/commands/math/stddev.rs
@@ -43,7 +43,7 @@ impl WholeStreamCommand for SubCommand {
             let mut column_values = IndexMap::new();
             for value in values {
                 if let UntaggedValue::Row(row_dict) = &value.value {
-                    for (key, value) in row_dict.entries.iter() {
+                    for (key, value) in &row_dict.entries {
                         column_values
                             .entry(key.clone())
                             .and_modify(|v: &mut Vec<Value>| v.push(value.clone()))
diff --git a/crates/nu-command/src/commands/math/utils.rs b/crates/nu-command/src/commands/math/utils.rs
index 25ad50437..19ee44b84 100644
--- a/crates/nu-command/src/commands/math/utils.rs
+++ b/crates/nu-command/src/commands/math/utils.rs
@@ -67,7 +67,7 @@ pub fn calculate(values: &[Value], name: &Tag, mf: MathFunction) -> Result<Value
         let mut column_values = IndexMap::new();
         for value in values {
             if let UntaggedValue::Row(row_dict) = &value.value {
-                for (key, value) in row_dict.entries.iter() {
+                for (key, value) in &row_dict.entries {
                     column_values
                         .entry(key.clone())
                         .and_modify(|v: &mut Vec<Value>| v.push(value.clone()))
diff --git a/crates/nu-command/src/commands/math/variance.rs b/crates/nu-command/src/commands/math/variance.rs
index 92b80a65f..a73b4e60f 100644
--- a/crates/nu-command/src/commands/math/variance.rs
+++ b/crates/nu-command/src/commands/math/variance.rs
@@ -39,7 +39,7 @@ impl WholeStreamCommand for SubCommand {
             let mut column_values = IndexMap::new();
             for value in values {
                 if let UntaggedValue::Row(row_dict) = &value.value {
-                    for (key, value) in row_dict.entries.iter() {
+                    for (key, value) in &row_dict.entries {
                         column_values
                             .entry(key.clone())
                             .and_modify(|v: &mut Vec<Value>| v.push(value.clone()))
diff --git a/crates/nu-command/src/commands/mod.rs b/crates/nu-command/src/commands/mod.rs
index 9e91c9ba6..4c53d1827 100644
--- a/crates/nu-command/src/commands/mod.rs
+++ b/crates/nu-command/src/commands/mod.rs
@@ -112,10 +112,7 @@ mod tests {
 
     fn only_examples() -> Vec<Command> {
         let mut commands = full_tests();
-        commands.extend(vec![
-            whole_stream_command(Zip),
-            whole_stream_command(Flatten),
-        ]);
+        commands.extend([whole_stream_command(Zip), whole_stream_command(Flatten)]);
         commands
     }
 
diff --git a/crates/nu-command/src/commands/network/post.rs b/crates/nu-command/src/commands/network/post.rs
index 162a1b8a0..a3417bfa8 100644
--- a/crates/nu-command/src/commands/network/post.rs
+++ b/crates/nu-command/src/commands/network/post.rs
@@ -519,7 +519,7 @@ pub fn value_to_json_value(v: &Value) -> Result<serde_json::Value, ShellError> {
         UntaggedValue::Primitive(Primitive::Binary(b)) => {
             let mut output = vec![];
 
-            for item in b.iter() {
+            for item in b {
                 output.push(serde_json::Value::Number(
                     serde_json::Number::from_f64(*item as f64).ok_or_else(|| {
                         ShellError::labeled_error(
@@ -534,7 +534,7 @@ pub fn value_to_json_value(v: &Value) -> Result<serde_json::Value, ShellError> {
         }
         UntaggedValue::Row(o) => {
             let mut m = serde_json::Map::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(k.clone(), value_to_json_value(v)?);
             }
             serde_json::Value::Object(m)
diff --git a/crates/nu-command/src/commands/platform/clear.rs b/crates/nu-command/src/commands/platform/clear.rs
index 2b26dc306..e5dde549d 100644
--- a/crates/nu-command/src/commands/platform/clear.rs
+++ b/crates/nu-command/src/commands/platform/clear.rs
@@ -22,12 +22,12 @@ impl WholeStreamCommand for Clear {
     fn run(&self, _: CommandArgs) -> Result<InputStream, ShellError> {
         if cfg!(windows) {
             Command::new("cmd")
-                .args(&["/C", "cls"])
+                .args(["/C", "cls"])
                 .status()
                 .expect("failed to execute process");
         } else if cfg!(unix) {
             Command::new("/bin/sh")
-                .args(&["-c", "clear"])
+                .args(["-c", "clear"])
                 .status()
                 .expect("failed to execute process");
         }
diff --git a/crates/nu-command/src/commands/platform/clip.rs b/crates/nu-command/src/commands/platform/clip.rs
index 6cb67cd7d..8bc9e1c3b 100644
--- a/crates/nu-command/src/commands/platform/clip.rs
+++ b/crates/nu-command/src/commands/platform/clip.rs
@@ -51,7 +51,7 @@ pub fn clip(args: CommandArgs) -> Result<ActionStream, ShellError> {
 
         if !values.is_empty() {
             let mut first = true;
-            for i in values.iter() {
+            for i in &values {
                 if !first {
                     new_copy_data.push('\n');
                 } else {
diff --git a/crates/nu-command/src/commands/platform/du.rs b/crates/nu-command/src/commands/platform/du.rs
index bd100050f..efc508bc6 100644
--- a/crates/nu-command/src/commands/platform/du.rs
+++ b/crates/nu-command/src/commands/platform/du.rs
@@ -99,7 +99,7 @@ fn du(args: CommandArgs) -> Result<ActionStream, ShellError> {
 
     let exclude = args.exclude.map_or(Ok(None), move |x| {
         Pattern::new(&x.item)
-            .map(Option::Some)
+            .map(Some)
             .map_err(|e| ShellError::labeled_error(e.msg, "glob error", x.tag.clone()))
     })?;
 
@@ -148,11 +148,10 @@ fn du(args: CommandArgs) -> Result<ActionStream, ShellError> {
                     output.push(Ok(ReturnSuccess::Value(
                         DirInfo::new(p, &params, max_depth, ctrl_c.clone()).into(),
                     )));
-                } else {
-                    for v in FileInfo::new(p, deref, tag.clone()).into_iter() {
-                        output.push(Ok(ReturnSuccess::Value(v.into())));
-                    }
+                } else if let Ok(v) = FileInfo::new(p, deref, tag.clone()) {
+                    output.push(Ok(ReturnSuccess::Value(v.into())));
                 }
+
                 output
             }
             Err(e) => vec![Err(e)],
diff --git a/crates/nu-command/src/commands/platform/exec.rs b/crates/nu-command/src/commands/platform/exec.rs
index 236741a44..429b5498c 100644
--- a/crates/nu-command/src/commands/platform/exec.rs
+++ b/crates/nu-command/src/commands/platform/exec.rs
@@ -80,7 +80,7 @@ fn exec(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Err(ShellError::labeled_error(
         "Error on exec",
-        format!("{}", err),
+        err.to_string(),
         &name,
     ))
 }
diff --git a/crates/nu-command/src/commands/random/dice.rs b/crates/nu-command/src/commands/random/dice.rs
index 0c64f0568..1b13d2f29 100644
--- a/crates/nu-command/src/commands/random/dice.rs
+++ b/crates/nu-command/src/commands/random/dice.rs
@@ -82,7 +82,7 @@ pub fn dice(args: CommandArgs) -> Result<OutputStream, ShellError> {
         UntaggedValue::int(thread_rng.gen_range(1..sides + 1)).into_value(tag.clone())
     });
 
-    Ok((iter).into_output_stream())
+    Ok(iter.into_output_stream())
 }
 
 #[cfg(test)]
diff --git a/crates/nu-command/src/commands/strings/format/command.rs b/crates/nu-command/src/commands/strings/format/command.rs
index 4ac809156..eb402e3cd 100644
--- a/crates/nu-command/src/commands/strings/format/command.rs
+++ b/crates/nu-command/src/commands/strings/format/command.rs
@@ -66,7 +66,7 @@ fn format_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
                         ctx.scope.enter_scope();
                         ctx.scope.add_var("$it", value.clone());
-                        let result = evaluate_baseline_expr(&full_column_path.0, &*ctx);
+                        let result = evaluate_baseline_expr(&full_column_path.0, &ctx);
                         ctx.scope.exit_scope();
 
                         if let Ok(c) = result {
diff --git a/crates/nu-command/src/commands/strings/format/format_filesize.rs b/crates/nu-command/src/commands/strings/format/format_filesize.rs
index 1f2caf4da..23d56ffac 100644
--- a/crates/nu-command/src/commands/strings/format/format_filesize.rs
+++ b/crates/nu-command/src/commands/strings/format/format_filesize.rs
@@ -90,7 +90,7 @@ fn filesize(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     Ok(args
         .input
-        .map(move |input| {
+        .flat_map(move |input| {
             let format = format.clone();
             let field = field.clone();
 
@@ -99,7 +99,6 @@ fn filesize(args: CommandArgs) -> Result<OutputStream, ShellError> {
                 Err(e) => Err(e),
             }
         })
-        .flatten()
         .map(Ok)
         .into_input_stream())
 }
diff --git a/crates/nu-command/src/commands/strings/lines.rs b/crates/nu-command/src/commands/strings/lines.rs
index af68824b7..5d8a588dc 100644
--- a/crates/nu-command/src/commands/strings/lines.rs
+++ b/crates/nu-command/src/commands/strings/lines.rs
@@ -91,7 +91,7 @@ fn lines(args: CommandArgs) -> Result<ActionStream, ShellError> {
                     value: UntaggedValue::Primitive(Primitive::EndOfStream),
                     ..
                 } => {
-                    let st = (&*leftover_string).lock().clone();
+                    let st = leftover_string.lock().clone();
                     if !st.is_empty() {
                         Some(vec![ReturnSuccess::value(
                             UntaggedValue::string(st).into_untagged_value(),
diff --git a/crates/nu-command/src/commands/strings/parse/command.rs b/crates/nu-command/src/commands/strings/parse/command.rs
index 4db950671..656555d69 100644
--- a/crates/nu-command/src/commands/strings/parse/command.rs
+++ b/crates/nu-command/src/commands/strings/parse/command.rs
@@ -176,15 +176,14 @@ fn parse_regex_error(e: regex::Error, base_span: Span) -> ShellError {
                 .map(|l| l.replace(':', ""))
                 .expect("invalid regex pattern");
 
-            let span = lines.nth(1).map(|l| l.find('^')).flatten().map(|space| {
+            let span = lines.nth(1).and_then(|l| l.find('^')).map(|space| {
                 let start = base_span.start() + space - 3;
                 Span::for_char(start)
             });
 
             let msg = lines
                 .next()
-                .map(|l| l.split(':').nth(1))
-                .flatten()
+                .and_then(|l| l.split(':').nth(1))
                 .map(|s| s.trim().to_string());
 
             match (msg, span) {
diff --git a/crates/nu-command/src/commands/strings/split/column.rs b/crates/nu-command/src/commands/strings/split/column.rs
index f97ff261b..d8c7a4665 100644
--- a/crates/nu-command/src/commands/strings/split/column.rs
+++ b/crates/nu-command/src/commands/strings/split/column.rs
@@ -69,14 +69,14 @@ fn split_column(args: CommandArgs) -> Result<ActionStream, ShellError> {
                     }
 
                     let mut dict = TaggedDictBuilder::new(&v.tag);
-                    for (&k, v) in split_result.iter().zip(gen_columns.iter()) {
+                    for (&k, v) in split_result.iter().zip(&gen_columns) {
                         dict.insert_untagged(v.clone(), Primitive::String(k.into()));
                     }
 
                     ReturnSuccess::value(dict.into_value())
                 } else {
                     let mut dict = TaggedDictBuilder::new(&v.tag);
-                    for (&k, v) in split_result.iter().zip(positional.iter()) {
+                    for (&k, v) in split_result.iter().zip(&positional) {
                         dict.insert_untagged(
                             v,
                             UntaggedValue::Primitive(Primitive::String(k.into())),
diff --git a/crates/nu-command/src/commands/strings/str_/lpad.rs b/crates/nu-command/src/commands/strings/str_/lpad.rs
index 57bdecd2b..7ec42130e 100644
--- a/crates/nu-command/src/commands/strings/str_/lpad.rs
+++ b/crates/nu-command/src/commands/strings/str_/lpad.rs
@@ -125,7 +125,7 @@ fn action(
                 )
             } else {
                 let mut res = character.repeat(**length - s.chars().count());
-                res += s.as_ref();
+                res += s;
                 Ok(UntaggedValue::string(res).into_value(tag))
             }
         }
diff --git a/crates/nu-command/src/commands/strings/str_/rpad.rs b/crates/nu-command/src/commands/strings/str_/rpad.rs
index 08c496a52..35b639100 100644
--- a/crates/nu-command/src/commands/strings/str_/rpad.rs
+++ b/crates/nu-command/src/commands/strings/str_/rpad.rs
@@ -125,7 +125,7 @@ fn action(
                 )
             } else {
                 let mut res = s.to_string();
-                res += character.repeat(**length - s.chars().count()).as_str();
+                res += &character.repeat(**length - s.chars().count());
                 Ok(UntaggedValue::string(res).into_value(tag))
             }
         }
diff --git a/crates/nu-command/src/commands/strings/str_/substring.rs b/crates/nu-command/src/commands/strings/str_/substring.rs
index 182fe3cd8..594654006 100644
--- a/crates/nu-command/src/commands/strings/str_/substring.rs
+++ b/crates/nu-command/src/commands/strings/str_/substring.rs
@@ -343,7 +343,7 @@ mod tests {
             expectation("", (6, -6)),
         ];
 
-        for expectation in cases.iter() {
+        for expectation in &cases {
             let expected = expectation.expected;
             let actual = action(&word, &expectation.options(), Tag::unknown()).unwrap();
 
diff --git a/crates/nu-command/src/commands/system/ps.rs b/crates/nu-command/src/commands/system/ps.rs
index 65fd5f034..85dc6400c 100644
--- a/crates/nu-command/src/commands/system/ps.rs
+++ b/crates/nu-command/src/commands/system/ps.rs
@@ -47,7 +47,7 @@ fn run_ps(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     let result: Vec<_> = sys.processes().iter().map(|x| *x.0).collect();
 
-    for pid in result.into_iter() {
+    for pid in result {
         if let Some(result) = sys.process(pid) {
             let mut dict = TaggedDictBuilder::new(args.name_tag());
             dict.insert_untagged("pid", UntaggedValue::int(pid as i64));
diff --git a/crates/nu-command/src/commands/viewers/autoview/command.rs b/crates/nu-command/src/commands/viewers/autoview/command.rs
index c829a1983..948533277 100644
--- a/crates/nu-command/src/commands/viewers/autoview/command.rs
+++ b/crates/nu-command/src/commands/viewers/autoview/command.rs
@@ -206,7 +206,7 @@ pub fn autoview(args: CommandArgs) -> Result<OutputStream, ShellError> {
                                     > term_width)
                         {
                             let mut entries = vec![];
-                            for (key, value) in row.entries.iter() {
+                            for (key, value) in &row.entries {
                                 entries.push(vec![
                                     nu_table::StyledString::new(
                                         key.to_string(),
diff --git a/crates/nu-command/src/examples.rs b/crates/nu-command/src/examples.rs
index 2a4c27a47..7389b6708 100644
--- a/crates/nu-command/src/examples.rs
+++ b/crates/nu-command/src/examples.rs
@@ -61,7 +61,7 @@ pub fn test_examples(cmd: Command) -> Result<(), ShellError> {
         if let Some(expected) = &sample_pipeline.result {
             let result = evaluate_block(block, &mut ctx)?;
 
-            ctx.with_errors(|reasons| reasons.iter().cloned().take(1).next())
+            ctx.with_errors(|reasons| reasons.iter().cloned().next())
                 .map_or(Ok(()), Err)?;
 
             if expected.len() != result.len() {
@@ -75,7 +75,7 @@ pub fn test_examples(cmd: Command) -> Result<(), ShellError> {
                 );
             }
 
-            for (e, a) in expected.iter().zip(result.iter()) {
+            for (e, a) in expected.iter().zip(&result) {
                 if !values_equal(e, a) {
                     let row_errored = format!("expected: {:#?}\nactual: {:#?}", e, a);
                     let failed_call = format!("command: {}\n", sample_pipeline.example);
@@ -140,7 +140,7 @@ pub fn test(cmd: impl WholeStreamCommand + 'static) -> Result<(), ShellError> {
                 );
             }
 
-            for (e, a) in expected.iter().zip(result.iter()) {
+            for (e, a) in expected.iter().zip(&result) {
                 if !values_equal(e, a) {
                     let row_errored = format!("expected: {:#?}\nactual: {:#?}", e, a);
                     let failed_call = format!("command: {}\n", sample_pipeline.example);
@@ -275,10 +275,10 @@ pub fn test_anchors(cmd: Command) -> Result<(), ShellError> {
         if sample_pipeline.result.is_some() {
             let result = evaluate_block(block, &mut ctx)?;
 
-            ctx.with_errors(|reasons| reasons.iter().cloned().take(1).next())
+            ctx.with_errors(|reasons| reasons.iter().cloned().next())
                 .map_or(Ok(()), Err)?;
 
-            for actual in result.iter() {
+            for actual in &result {
                 if !is_anchor_carried(actual, mock_path()) {
                     let failed_call = format!("command: {}\n", pipeline_with_anchor);
 
@@ -351,10 +351,10 @@ fn values_equal(expected: &Value, actual: &Value) -> bool {
 
             e.entries
                 .iter()
-                .zip(a.entries.iter())
+                .zip(&a.entries)
                 .all(|((ek, ev), (ak, av))| ek == ak && values_equal(ev, av))
         }
-        (Table(e), Table(a)) => e.iter().zip(a.iter()).all(|(e, a)| values_equal(e, a)),
+        (Table(e), Table(a)) => e.iter().zip(a).all(|(e, a)| values_equal(e, a)),
         (e, a) => unimplemented!("{} {}", e.type_name(), a.type_name()),
     }
 }
diff --git a/crates/nu-command/src/examples/double_echo.rs b/crates/nu-command/src/examples/double_echo.rs
index 577674706..e06e3ae27 100644
--- a/crates/nu-command/src/examples/double_echo.rs
+++ b/crates/nu-command/src/examples/double_echo.rs
@@ -38,7 +38,7 @@ impl WholeStreamCommand for Command {
             base_value = first.clone()
         }
 
-        let stream = rest.into_iter().map(move |i| {
+        let stream = rest.into_iter().flat_map(move |i| {
             let base_value = base_value.clone();
             match i.as_string() {
                 Ok(s) => ActionStream::one(Ok(ReturnSuccess::Value(Value {
@@ -52,9 +52,9 @@ impl WholeStreamCommand for Command {
                     } => {
                         if table.len() == 1 && table[0].is_table() {
                             let mut values: Vec<Value> =
-                                table[0].table_entries().map(Clone::clone).collect();
+                                table[0].table_entries().cloned().collect();
 
-                            for v in values.iter_mut() {
+                            for v in &mut values {
                                 v.tag = base_value.tag();
                             }
 
@@ -81,6 +81,6 @@ impl WholeStreamCommand for Command {
             }
         });
 
-        Ok((stream).flatten().into_action_stream())
+        Ok(stream.into_action_stream())
     }
 }
diff --git a/crates/nu-command/tests/commands/math/sum.rs b/crates/nu-command/tests/commands/math/sum.rs
index 6ce01ea72..4e3623d81 100644
--- a/crates/nu-command/tests/commands/math/sum.rs
+++ b/crates/nu-command/tests/commands/math/sum.rs
@@ -42,14 +42,14 @@ fn compute_sum_of_individual_row() -> Result<(), String> {
         ("mem", 3032375296.),
         ("virtual", 102579965952.),
     ];
-    for (column_name, expected_value) in answers_for_columns.iter() {
+    for (column_name, expected_value) in answers_for_columns {
         let actual = nu!(
             cwd: "tests/fixtures/formats/",
             format!("open sample-ps-output.json | select {} | math sum | get {}", column_name, column_name)
         );
         let result =
             f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?;
-        assert_eq!(result, *expected_value);
+        assert_eq!(result, expected_value);
     }
     Ok(())
 }
@@ -63,14 +63,14 @@ fn compute_sum_of_table() -> Result<(), String> {
         ("mem", 3032375296.),
         ("virtual", 102579965952.),
     ];
-    for (column_name, expected_value) in answers_for_columns.iter() {
+    for (column_name, expected_value) in answers_for_columns {
         let actual = nu!(
             cwd: "tests/fixtures/formats/",
             format!("open sample-ps-output.json | select cpu mem virtual | math sum | get {}", column_name)
         );
         let result =
             f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?;
-        assert_eq!(result, *expected_value);
+        assert_eq!(result, expected_value);
     }
     Ok(())
 }
diff --git a/crates/nu-completion/src/command.rs b/crates/nu-completion/src/command.rs
index 9d7eb45fc..7db121de2 100644
--- a/crates/nu-completion/src/command.rs
+++ b/crates/nu-completion/src/command.rs
@@ -25,7 +25,7 @@ where
         let path_executables = find_path_executables().unwrap_or_default();
 
         // TODO quote these, if necessary
-        commands.extend(path_executables.into_iter());
+        commands.extend(path_executables);
 
         let mut suggestions: Vec<_> = commands
             .into_iter()
diff --git a/crates/nu-completion/src/completer.rs b/crates/nu-completion/src/completer.rs
index ee0d4512b..def926f02 100644
--- a/crates/nu-completion/src/completer.rs
+++ b/crates/nu-completion/src/completer.rs
@@ -37,7 +37,7 @@ impl NuCompleter {
             .and_then(|cfg| cfg.get("line_editor").cloned())
             .and_then(|le| {
                 le.row_entries()
-                    .find(|(idx, _value)| idx.as_str() == "completion_match_method")
+                    .find(|&(idx, _value)| idx == "completion_match_method")
                     .and_then(|(_idx, value)| value.as_string().ok())
             })
             .unwrap_or_else(String::new);
diff --git a/crates/nu-completion/src/engine.rs b/crates/nu-completion/src/engine.rs
index 44a201b44..8f5e648b0 100644
--- a/crates/nu-completion/src/engine.rs
+++ b/crates/nu-completion/src/engine.rs
@@ -306,7 +306,7 @@ mod tests {
         }
 
         fn get_signature(&self, name: &str) -> Option<nu_protocol::Signature> {
-            self.0.iter().find(|v| v.name == name).map(Clone::clone)
+            self.0.iter().find(|v| v.name == name).cloned()
         }
 
         fn get_alias(&self, _name: &str) -> Option<Vec<Spanned<String>>> {
diff --git a/crates/nu-completion/src/flag.rs b/crates/nu-completion/src/flag.rs
index fe4b23e6b..88b8ddaf8 100644
--- a/crates/nu-completion/src/flag.rs
+++ b/crates/nu-completion/src/flag.rs
@@ -12,7 +12,7 @@ where
     fn complete(&self, ctx: &Context, partial: &str, matcher: &dyn Matcher) -> Vec<Suggestion> {
         if let Some(sig) = ctx.signature_registry().get(&self.cmd) {
             let mut suggestions = Vec::new();
-            for (name, (named_type, _desc)) in sig.named.iter() {
+            for (name, (named_type, _desc)) in &sig.named {
                 suggestions.push(format!("--{}", name));
 
                 if let Some(c) = named_type.get_short() {
diff --git a/crates/nu-completion/src/matchers/case_insensitive.rs b/crates/nu-completion/src/matchers/case_insensitive.rs
index e9f3d9551..9c3ad47a5 100644
--- a/crates/nu-completion/src/matchers/case_insensitive.rs
+++ b/crates/nu-completion/src/matchers/case_insensitive.rs
@@ -5,7 +5,7 @@ pub struct Matcher;
 impl matchers::Matcher for Matcher {
     fn matches(&self, partial: &str, from: &str) -> bool {
         from.to_ascii_lowercase()
-            .starts_with(partial.to_ascii_lowercase().as_str())
+            .starts_with(&partial.to_ascii_lowercase())
     }
 }
 
diff --git a/crates/nu-completion/src/path.rs b/crates/nu-completion/src/path.rs
index 801194ad0..ca84371b0 100644
--- a/crates/nu-completion/src/path.rs
+++ b/crates/nu-completion/src/path.rs
@@ -39,8 +39,8 @@ impl PathCompleter {
                 .filter_map(|entry| {
                     entry.ok().and_then(|entry| {
                         let mut file_name = entry.file_name().to_string_lossy().into_owned();
-                        if matcher.matches(partial, file_name.as_str()) {
-                            let mut path = format!("{}{}", &base_dir_name, file_name);
+                        if matcher.matches(partial, &file_name) {
+                            let mut path = format!("{}{}", base_dir_name, file_name);
                             if entry.path().is_dir() {
                                 path.push(SEP);
                                 file_name.push(SEP);
diff --git a/crates/nu-data/src/base.rs b/crates/nu-data/src/base.rs
index 326e15c71..0f6f5f2d1 100644
--- a/crates/nu-data/src/base.rs
+++ b/crates/nu-data/src/base.rs
@@ -45,7 +45,7 @@ pub fn select_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> Val
     let descs = obj.data_descriptors();
 
     for column_name in fields {
-        match descs.iter().find(|d| *d == column_name) {
+        match descs.iter().find(|&d| d == column_name) {
             None => out.insert_untagged(column_name, UntaggedValue::nothing()),
             Some(desc) => out.insert_value(desc.clone(), obj.get_data(desc).borrow().clone()),
         }
diff --git a/crates/nu-data/src/base/shape.rs b/crates/nu-data/src/base/shape.rs
index a110ba076..c2a912216 100644
--- a/crates/nu-data/src/base/shape.rs
+++ b/crates/nu-data/src/base/shape.rs
@@ -110,7 +110,7 @@ impl InlineShape {
     pub fn from_dictionary(dictionary: &Dictionary) -> InlineShape {
         let mut map = IndexMap::new();
 
-        for (key, value) in dictionary.entries.iter() {
+        for (key, value) in &dictionary.entries {
             let column = Column::String(key.clone());
             map.insert(column, InlineShape::from_value(value));
         }
@@ -119,11 +119,7 @@ impl InlineShape {
     }
 
     pub fn from_table<'a>(table: impl IntoIterator<Item = &'a Value>) -> InlineShape {
-        let mut vec = vec![];
-
-        for item in table.into_iter() {
-            vec.push(InlineShape::from_value(item))
-        }
+        let vec = table.into_iter().map(InlineShape::from_value).collect();
 
         InlineShape::Table(vec)
     }
@@ -150,7 +146,7 @@ impl InlineShape {
         match value.into() {
             UntaggedValue::Primitive(p) => InlineShape::from_primitive(p),
             UntaggedValue::Row(row) => InlineShape::from_dictionary(row),
-            UntaggedValue::Table(table) => InlineShape::from_table(table.iter()),
+            UntaggedValue::Table(table) => InlineShape::from_table(table),
             UntaggedValue::Error(_) => InlineShape::Error,
             UntaggedValue::Block(_) => InlineShape::Block,
             #[cfg(feature = "dataframe")]
@@ -261,10 +257,9 @@ impl InlineShape {
                 }
             }
         } else {
-            let doc = (DbgDocBldr::primitive(format!("{}", bytesize))
-                + DbgDocBldr::space()
-                + DbgDocBldr::kind("B"))
-            .group();
+            let doc =
+                (DbgDocBldr::primitive(bytesize) + DbgDocBldr::space() + DbgDocBldr::kind("B"))
+                    .group();
             (doc.clone(), InlineShape::render_doc(&doc))
         }
     }
@@ -284,8 +279,8 @@ impl PrettyDebug for FormatInlineShape {
 
         match &self.shape {
             InlineShape::Nothing => DbgDocBldr::blank(),
-            InlineShape::Int(int) => DbgDocBldr::primitive(format!("{}", int)),
-            InlineShape::BigInt(int) => DbgDocBldr::primitive(format!("{}", int)),
+            InlineShape::Int(int) => DbgDocBldr::primitive(int),
+            InlineShape::BigInt(int) => DbgDocBldr::primitive(int),
             InlineShape::Decimal(decimal) => DbgDocBldr::description(format_primitive(
                 &Primitive::Decimal(decimal.clone()),
                 None,
diff --git a/crates/nu-data/src/config.rs b/crates/nu-data/src/config.rs
index 33ab3c1e9..3181db46a 100644
--- a/crates/nu-data/src/config.rs
+++ b/crates/nu-data/src/config.rs
@@ -47,7 +47,7 @@ pub fn convert_toml_value_to_nu_value(v: &toml::Value, tag: impl Into<Tag>) -> V
         toml::Value::Table(t) => {
             let mut collected = TaggedDictBuilder::new(&tag);
 
-            for (k, v) in t.iter() {
+            for (k, v) in t {
                 collected.insert_value(k.clone(), convert_toml_value_to_nu_value(v, &tag));
             }
 
@@ -127,7 +127,7 @@ fn helper(v: &Value) -> Result<toml::Value, ShellError> {
         }
         UntaggedValue::Row(o) => {
             let mut m = toml::map::Map::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(k.clone(), helper(v)?);
             }
             toml::Value::Table(m)
@@ -141,7 +141,7 @@ pub fn value_to_toml_value(v: &Value) -> Result<toml::Value, ShellError> {
     match &v.value {
         UntaggedValue::Row(o) => {
             let mut m = toml::map::Map::new();
-            for (k, v) in o.entries.iter() {
+            for (k, v) in &o.entries {
                 m.insert(k.clone(), helper(v)?);
             }
             Ok(toml::Value::Table(m))
@@ -185,10 +185,7 @@ pub fn default_path() -> Result<PathBuf, ShellError> {
 
 pub fn default_path_for(file: &Option<PathBuf>) -> Result<PathBuf, ShellError> {
     let mut filename = config_path()?;
-    let file: &Path = file
-        .as_ref()
-        .map(AsRef::as_ref)
-        .unwrap_or_else(|| "config.toml".as_ref());
+    let file: &Path = file.as_deref().unwrap_or_else(|| "config.toml".as_ref());
     filename.push(file);
 
     Ok(filename)
diff --git a/crates/nu-data/src/config/config_trust.rs b/crates/nu-data/src/config/config_trust.rs
index 01b516ed6..98012cdf8 100644
--- a/crates/nu-data/src/config/config_trust.rs
+++ b/crates/nu-data/src/config/config_trust.rs
@@ -39,6 +39,6 @@ pub fn read_trusted() -> Result<Trusted, ShellError> {
     let mut doc = String::new();
     file.read_to_string(&mut doc)?;
 
-    let allowed = toml::de::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
+    let allowed = toml::de::from_str(&doc).unwrap_or_else(|_| Trusted::new());
     Ok(allowed)
 }
diff --git a/crates/nu-data/src/config/path.rs b/crates/nu-data/src/config/path.rs
index 3e0f951ca..5a9fdb031 100644
--- a/crates/nu-data/src/config/path.rs
+++ b/crates/nu-data/src/config/path.rs
@@ -17,11 +17,7 @@ pub fn default_history_path() -> PathBuf {
 pub fn history_path(config: &NuConfig) -> Option<PathBuf> {
     config
         .var("history-path")
-        .map(|custom_path| match custom_path.as_string() {
-            Ok(path) => Some(PathBuf::from(path)),
-            Err(_) => None,
-        })
-        .flatten()
+        .and_then(|custom_path| custom_path.as_string().map(PathBuf::from).ok())
 }
 
 /// Get history path in config or default
diff --git a/crates/nu-data/src/dict.rs b/crates/nu-data/src/dict.rs
index 579ac5479..fa48110fc 100644
--- a/crates/nu-data/src/dict.rs
+++ b/crates/nu-data/src/dict.rs
@@ -44,7 +44,7 @@ impl DictionaryExt for Dictionary {
         let result = self
             .entries
             .iter()
-            .find(|(desc_name, _)| *desc_name == name.item)?
+            .find(|&(desc_name, _)| desc_name == name.item)?
             .1;
 
         Some(
@@ -58,7 +58,7 @@ impl DictionaryExt for Dictionary {
     fn get_mut_data_by_key(&mut self, name: &str) -> Option<&mut Value> {
         self.entries
             .iter_mut()
-            .find(|(desc_name, _)| *desc_name == name)
+            .find(|&(desc_name, _)| desc_name == name)
             .map_or_else(|| None, |x| Some(x.1))
     }
 
diff --git a/crates/nu-data/src/utils/group.rs b/crates/nu-data/src/utils/group.rs
index a8f176c24..75c020887 100644
--- a/crates/nu-data/src/utils/group.rs
+++ b/crates/nu-data/src/utils/group.rs
@@ -27,7 +27,7 @@ pub fn group(
 
     let mut out = TaggedDictBuilder::new(&tag);
 
-    for (k, v) in groups.iter() {
+    for (k, v) in &groups {
         out.insert_untagged(k, UntaggedValue::table(v));
     }
 
diff --git a/crates/nu-data/src/utils/internal.rs b/crates/nu-data/src/utils/internal.rs
index e924ba3a7..b9b05ef65 100644
--- a/crates/nu-data/src/utils/internal.rs
+++ b/crates/nu-data/src/utils/internal.rs
@@ -138,7 +138,7 @@ pub fn inner_max(data: &[Value]) -> Result<Value, ShellError> {
         .value
         .clone();
 
-    for value in data.iter() {
+    for value in data {
         if let Ok(greater_than) =
             crate::value::compare_values(Operator::GreaterThan, &value.value, &biggest)
         {
@@ -245,7 +245,7 @@ pub fn evaluate(
                 if let Some(ref evaluator) = evaluator {
                     let mut evaluations = vec![];
 
-                    for set in values.iter() {
+                    for set in values {
                         evaluations.push(evaluator(idx, set)?);
                     }
 
diff --git a/crates/nu-data/src/utils/split.rs b/crates/nu-data/src/utils/split.rs
index 5dddacdb1..94c43befd 100644
--- a/crates/nu-data/src/utils/split.rs
+++ b/crates/nu-data/src/utils/split.rs
@@ -51,7 +51,7 @@ pub fn split(
 
     let mut out = TaggedDictBuilder::new(&tag);
 
-    for (k, v) in splits.into_iter() {
+    for (k, v) in splits {
         out.insert_untagged(k, UntaggedValue::row(v));
     }
 
diff --git a/crates/nu-engine/src/documentation.rs b/crates/nu-engine/src/documentation.rs
index 0a30a32cc..a2da169fa 100644
--- a/crates/nu-engine/src/documentation.rs
+++ b/crates/nu-engine/src/documentation.rs
@@ -83,7 +83,7 @@ pub fn generate_docs(scope: &Scope) -> Value {
     // Return documentation for each command
     // Sub-commands are nested under their respective parent commands
     let mut table = Vec::new();
-    for name in sorted_names.iter() {
+    for name in &sorted_names {
         // Must be a sub-command, skip since it's being handled underneath when we hit the parent command
         if !cmap.contains_key(name) {
             continue;
@@ -91,7 +91,7 @@ pub fn generate_docs(scope: &Scope) -> Value {
         let mut row_entries = generate_doc(name, scope);
         // Iterate over all the subcommands of the parent command
         let mut sub_table = Vec::new();
-        for sub_name in cmap.get(name).unwrap_or(&Vec::new()).iter() {
+        for sub_name in cmap.get(name).unwrap_or(&Vec::new()) {
             let sub_row = generate_doc(sub_name, scope);
             sub_table.push(UntaggedValue::row(sub_row).into_untagged_value());
         }
diff --git a/crates/nu-engine/src/evaluate/block.rs b/crates/nu-engine/src/evaluate/block.rs
index 5498a01b5..7607a6af5 100644
--- a/crates/nu-engine/src/evaluate/block.rs
+++ b/crates/nu-engine/src/evaluate/block.rs
@@ -19,7 +19,7 @@ pub fn run_block(
     external_redirection: ExternalRedirection,
 ) -> Result<OutputStream, ShellError> {
     let mut output: Result<InputStream, ShellError> = Ok(OutputStream::empty());
-    for (_, definition) in block.definitions.iter() {
+    for definition in block.definitions.values() {
         ctx.scope.add_definition(definition.clone());
     }
 
@@ -166,12 +166,8 @@ fn run_pipeline(
                     UntaggedValue::Block(captured_block) => {
                         ctx.scope.enter_scope();
                         ctx.scope.add_vars(&captured_block.captured.entries);
-                        for (param, value) in captured_block
-                            .block
-                            .params
-                            .positional
-                            .iter()
-                            .zip(args.iter())
+                        for (param, value) in
+                            captured_block.block.params.positional.iter().zip(&args)
                         {
                             ctx.scope.add_var(param.0.name(), value[0].clone());
                         }
@@ -188,7 +184,7 @@ fn run_pipeline(
                 }
             }
 
-            ClassifiedCommand::Expr(expr) => run_expression_block(&*expr, ctx)?,
+            ClassifiedCommand::Expr(expr) => run_expression_block(expr, ctx)?,
 
             ClassifiedCommand::Error(err) => return Err(err.clone().into()),
 
diff --git a/crates/nu-engine/src/evaluate/evaluate_args.rs b/crates/nu-engine/src/evaluate/evaluate_args.rs
index c11d5e1c1..ecf47e244 100644
--- a/crates/nu-engine/src/evaluate/evaluate_args.rs
+++ b/crates/nu-engine/src/evaluate/evaluate_args.rs
@@ -27,7 +27,7 @@ pub(crate) fn evaluate_args(
     let mut named_args = IndexMap::new();
 
     if let Some(named) = &call.named {
-        for (name, value) in named.iter() {
+        for (name, value) in named {
             match value {
                 hir::NamedValue::PresentSwitch(tag) => {
                     named_args.insert(name.clone(), UntaggedValue::boolean(true).into_value(tag));
diff --git a/crates/nu-engine/src/evaluate/evaluator.rs b/crates/nu-engine/src/evaluate/evaluator.rs
index 68d99058f..005f4d3dc 100644
--- a/crates/nu-engine/src/evaluate/evaluator.rs
+++ b/crates/nu-engine/src/evaluate/evaluator.rs
@@ -127,7 +127,7 @@ pub fn evaluate_baseline_expr(
                 }
 
                 let mut row_output = IndexMap::new();
-                for cell in output_headers.iter().zip(row.iter()) {
+                for cell in output_headers.iter().zip(row) {
                     let val = evaluate_baseline_expr(cell.1, ctx)?;
                     row_output.insert(cell.0.clone(), val);
                 }
diff --git a/crates/nu-engine/src/evaluate/scope.rs b/crates/nu-engine/src/evaluate/scope.rs
index 3586a778c..32b6dc472 100644
--- a/crates/nu-engine/src/evaluate/scope.rs
+++ b/crates/nu-engine/src/evaluate/scope.rs
@@ -41,7 +41,7 @@ impl Scope {
         let mut output: IndexMap<String, Vec<Spanned<String>>> = IndexMap::new();
 
         for frame in self.frames.lock().iter().rev() {
-            for v in frame.aliases.iter() {
+            for v in &frame.aliases {
                 if !output.contains_key(v.0) {
                     output.insert(v.0.clone(), v.1.clone());
                 }
@@ -55,7 +55,7 @@ impl Scope {
         let mut output: IndexMap<String, Signature> = IndexMap::new();
 
         for frame in self.frames.lock().iter().rev() {
-            for (name, command) in frame.commands.iter() {
+            for (name, command) in &frame.commands {
                 if !output.contains_key(name) {
                     let mut sig = command.signature();
                     // don't show --help and -h in the command arguments for $scope.commands
@@ -72,7 +72,7 @@ impl Scope {
         let mut output: IndexMap<String, Command> = IndexMap::new();
 
         for frame in self.frames.lock().iter().rev() {
-            for (name, command) in frame.commands.iter() {
+            for (name, command) in &frame.commands {
                 if !output.contains_key(name) {
                     output.insert(name.clone(), command.clone());
                 }
@@ -91,7 +91,7 @@ impl Scope {
         let mut output: IndexMap<String, Value> = IndexMap::new();
 
         for frame in self.frames.lock().iter().rev() {
-            for v in frame.vars.iter() {
+            for v in &frame.vars {
                 if !output.contains_key(v.0) {
                     output.insert(v.0.clone(), v.1.clone());
                 }
@@ -212,7 +212,7 @@ impl Scope {
         let mut output = IndexMap::new();
 
         for frame in self.frames.lock().iter().rev() {
-            for v in frame.env.iter() {
+            for v in &frame.env {
                 if !output.contains_key(v.0) {
                     output.insert(v.0.clone(), v.1.clone());
                 }
diff --git a/crates/nu-engine/src/evaluate/variables.rs b/crates/nu-engine/src/evaluate/variables.rs
index a6c97fabf..421cb71e7 100644
--- a/crates/nu-engine/src/evaluate/variables.rs
+++ b/crates/nu-engine/src/evaluate/variables.rs
@@ -16,7 +16,7 @@ pub fn nu(scope: &Scope, ctx: &EvaluationContext) -> Result<Value, ShellError> {
 
     let mut dict = TaggedDictBuilder::new(&tag);
 
-    for v in env.iter() {
+    for v in env {
         if v.0 != "PATH" && v.0 != "Path" {
             dict.insert_untagged(v.0, UntaggedValue::string(v.1));
         }
@@ -63,7 +63,7 @@ pub fn nu(scope: &Scope, ctx: &EvaluationContext) -> Result<Value, ShellError> {
     // For now, we work around the discrepency as best we can by merging the two into what is shown to the user as the
     // 'path' column of `$nu`
     let mut table = vec![];
-    for v in env.iter() {
+    for v in env {
         if v.0 == "PATH" || v.0 == "Path" {
             for path in std::env::split_paths(&v.1) {
                 table.push(UntaggedValue::filepath(path).into_value(&tag));
@@ -110,11 +110,11 @@ pub fn scope(
     let mut scope_dict = TaggedDictBuilder::new(&tag);
 
     let mut aliases_dict = TaggedDictBuilder::new(&tag);
-    for v in aliases.iter() {
+    for v in aliases {
         let values = v.1.clone();
         let mut vec = Vec::new();
 
-        for k in values.iter() {
+        for k in &values {
             vec.push(k.to_string());
         }
 
@@ -124,7 +124,7 @@ pub fn scope(
     }
 
     let mut commands_dict = TaggedDictBuilder::new(&tag);
-    for (name, signature) in commands.iter() {
+    for (name, signature) in commands {
         commands_dict.insert_untagged(name, UntaggedValue::string(&signature.allowed().join(" ")))
     }
 
diff --git a/crates/nu-engine/src/evaluation_context.rs b/crates/nu-engine/src/evaluation_context.rs
index 473dc4ff2..981a05231 100644
--- a/crates/nu-engine/src/evaluation_context.rs
+++ b/crates/nu-engine/src/evaluation_context.rs
@@ -432,7 +432,7 @@ impl VariableRegistry for EvaluationContext {
     fn variables(&self) -> Vec<String> {
         Variable::list()
             .into_iter()
-            .chain(self.scope.get_variable_names().into_iter())
+            .chain(self.scope.get_variable_names())
             .unique()
             .collect()
     }
diff --git a/crates/nu-engine/src/filesystem/filesystem_shell.rs b/crates/nu-engine/src/filesystem/filesystem_shell.rs
index afc9cd74f..e483ac2cf 100644
--- a/crates/nu-engine/src/filesystem/filesystem_shell.rs
+++ b/crates/nu-engine/src/filesystem/filesystem_shell.rs
@@ -491,7 +491,7 @@ impl Shell for FilesystemShell {
             ));
         }
 
-        for dir in directories.iter() {
+        for dir in &directories {
             let create_at = path.join(&dir.item);
 
             let dir_res = std::fs::create_dir_all(&create_at);
@@ -660,7 +660,7 @@ impl Shell for FilesystemShell {
                                 // It is not appropriate to try and remove the
                                 // current directory or its parent when using
                                 // glob patterns.
-                                let name = format!("{}", f.display());
+                                let name = f.display().to_string();
                                 if name.ends_with("/.") || name.ends_with("/..") {
                                     continue;
                                 }
@@ -1056,10 +1056,8 @@ pub(crate) fn dir_entry_dict(
         {
             for column in [
                 "name", "type", "target", "readonly", "size", "created", "accessed", "modified",
-            ]
-            .iter()
-            {
-                dict.insert_untagged(*column, UntaggedValue::nothing());
+            ] {
+                dict.insert_untagged(column, UntaggedValue::nothing());
             }
         }
 
@@ -1079,18 +1077,16 @@ pub(crate) fn dir_entry_dict(
                 "created",
                 "accessed",
                 "modified",
-            ]
-            .iter()
-            {
-                dict.insert_untagged(&(*column.to_owned()), UntaggedValue::nothing());
+            ] {
+                dict.insert_untagged(column, UntaggedValue::nothing());
             }
         }
     } else {
-        for column in ["name", "type", "target", "size", "modified"].iter() {
-            if *column == "target" {
+        for column in ["name", "type", "target", "size", "modified"] {
+            if column == "target" {
                 continue;
             }
-            dict.insert_untagged(*column, UntaggedValue::nothing());
+            dict.insert_untagged(column, UntaggedValue::nothing());
         }
     }
 
diff --git a/crates/nu-engine/src/plugin/build_plugin.rs b/crates/nu-engine/src/plugin/build_plugin.rs
index 0c790dfdb..7838ed9b1 100644
--- a/crates/nu-engine/src/plugin/build_plugin.rs
+++ b/crates/nu-engine/src/plugin/build_plugin.rs
@@ -22,7 +22,7 @@ pub fn build_plugin_command(
         Command::new("pwsh")
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
-            .args(&[
+            .args([
                 "-NoLogo",
                 "-NoProfile",
                 "-ExecutionPolicy",
diff --git a/crates/nu-engine/src/plugin/run_plugin.rs b/crates/nu-engine/src/plugin/run_plugin.rs
index 6790b0f54..0372185cc 100644
--- a/crates/nu-engine/src/plugin/run_plugin.rs
+++ b/crates/nu-engine/src/plugin/run_plugin.rs
@@ -133,8 +133,7 @@ fn run_filter(path: String, args: CommandArgs) -> Result<ActionStream, ShellErro
 
     let bos = vec![UntaggedValue::Primitive(Primitive::BeginningOfStream).into_untagged_value()]
         .into_iter();
-    let eos =
-        vec![UntaggedValue::Primitive(Primitive::EndOfStream).into_untagged_value()].into_iter();
+    let eos = [UntaggedValue::Primitive(Primitive::EndOfStream).into_untagged_value()];
 
     let (call_info, input) = evaluate_once(args)?;
 
@@ -149,7 +148,7 @@ fn run_filter(path: String, args: CommandArgs) -> Result<ActionStream, ShellErro
         Command::new("pwsh")
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
-            .args(&[
+            .args([
                 "-NoLogo",
                 "-NoProfile",
                 "-ExecutionPolicy",
@@ -172,7 +171,7 @@ fn run_filter(path: String, args: CommandArgs) -> Result<ActionStream, ShellErro
     Ok(bos
         .chain(input)
         .chain(eos)
-        .map(move |item| {
+        .flat_map(move |item| {
             match item {
                 Value {
                     value: UntaggedValue::Primitive(Primitive::BeginningOfStream),
@@ -201,7 +200,7 @@ fn run_filter(path: String, args: CommandArgs) -> Result<ActionStream, ShellErro
                                 Ok(_) => {}
                                 Err(err) => {
                                     return ActionStream::one(Err(ShellError::unexpected(
-                                        format!("{}", err),
+                                        err.to_string(),
                                     )));
                                 }
                             }
@@ -262,7 +261,7 @@ fn run_filter(path: String, args: CommandArgs) -> Result<ActionStream, ShellErro
                                 Ok(_) => {}
                                 Err(err) => {
                                     return ActionStream::one(Err(ShellError::unexpected(
-                                        format!("{}", err),
+                                        err.to_string(),
                                     )));
                                 }
                             }
@@ -371,7 +370,6 @@ fn run_filter(path: String, args: CommandArgs) -> Result<ActionStream, ShellErro
                 }
             }
         })
-        .flatten()
         .into_action_stream())
 }
 
@@ -435,7 +433,7 @@ fn run_sink(path: String, args: CommandArgs) -> Result<ActionStream, ShellError>
             // an example of what CallInfo would look like in this temp file
             let child = if ps1_file {
                 Command::new("pwsh")
-                    .args(&[
+                    .args([
                         "-NoLogo",
                         "-NoProfile",
                         "-ExecutionPolicy",
@@ -528,7 +526,7 @@ fn evaluate_args(call: &hir::Call, ctx: &EvaluationContext) -> Result<EvaluatedA
     let mut named_args = IndexMap::new();
 
     if let Some(named) = &call.named {
-        for (name, value) in named.iter() {
+        for (name, value) in named {
             match value {
                 hir::NamedValue::PresentSwitch(tag) => {
                     named_args.insert(name.clone(), UntaggedValue::boolean(true).into_value(tag));
diff --git a/crates/nu-engine/src/shell/painter.rs b/crates/nu-engine/src/shell/painter.rs
index 85b9d5389..bf1bcf908 100644
--- a/crates/nu-engine/src/shell/painter.rs
+++ b/crates/nu-engine/src/shell/painter.rs
@@ -68,7 +68,7 @@ impl Painter {
                     // Emit, as we changed styles
                     let intermediate = String::from_utf8_lossy(&self.original[idx_start..idx_end]);
 
-                    builder.push_str(&format!("{}", current_style.paint(intermediate)));
+                    builder.push_str(&current_style.paint(intermediate).to_string());
 
                     current_style = self.styles[idx_end];
                     idx_start = idx_end;
@@ -77,7 +77,7 @@ impl Painter {
             }
 
             let intermediate = String::from_utf8_lossy(&self.original[idx_start..idx_end]);
-            builder.push_str(&format!("{}", current_style.paint(intermediate)));
+            builder.push_str(&current_style.paint(intermediate).to_string());
 
             builder
         }
diff --git a/crates/nu-engine/src/shell/value_shell.rs b/crates/nu-engine/src/shell/value_shell.rs
index 5efc45a35..eb2a212ce 100644
--- a/crates/nu-engine/src/shell/value_shell.rs
+++ b/crates/nu-engine/src/shell/value_shell.rs
@@ -54,7 +54,7 @@ impl ValueShell {
         let mut viewed = self.value.clone();
         let sep_string = std::path::MAIN_SEPARATOR.to_string();
         let sep = OsStr::new(&sep_string);
-        for p in full_path.iter() {
+        for p in &full_path {
             match p {
                 x if x == sep => {}
                 step => {
@@ -107,7 +107,7 @@ impl Shell for ValueShell {
         let mut full_path = PathBuf::from(self.path());
 
         if let Some(value) = &path {
-            full_path.push(value.as_ref());
+            full_path.push(&value.item);
         }
 
         if self.find(&full_path).is_none() {
diff --git a/crates/nu-engine/src/types/deduction.rs b/crates/nu-engine/src/types/deduction.rs
index 2779d43f3..11a034913 100644
--- a/crates/nu-engine/src/types/deduction.rs
+++ b/crates/nu-engine/src/types/deduction.rs
@@ -323,7 +323,7 @@ fn get_result_shape_of_math_expr(
     scope: &Scope,
 ) -> Result<Option<SyntaxShape>, ShellError> {
     let mut shapes: Vec<Option<SyntaxShape>> = vec![];
-    for expr in &[&bin.left, &bin.right] {
+    for expr in [&bin.left, &bin.right] {
         let shape = match &expr.expr {
             Expression::Binary(deep_binary) => {
                 get_result_shape_of_math_expr(deep_binary, (pipeline_idx, pipeline), scope)?
@@ -1020,7 +1020,7 @@ impl VarSyntaxShapeDeductor {
                             merge_join_by(a, b, |a, b| {
                                 (a.deduction as i32).cmp(&(b.deduction as i32))
                             })
-                            .map(|either_or| match either_or {
+                            .filter_map(|either_or| match either_or {
                                 //Left is a, right is b
                                 //(a UNION none) OR a is a
                                 EitherOrBoth::Left(deduc) => Some(deduc.clone()),
@@ -1033,7 +1033,6 @@ impl VarSyntaxShapeDeductor {
                                     Some(combination)
                                 }
                             })
-                            .flatten()
                             .collect()
                         }
                         //No any's intersection of both is result
diff --git a/crates/nu-errors/src/lib.rs b/crates/nu-errors/src/lib.rs
index a0c242a21..8c16b82e5 100644
--- a/crates/nu-errors/src/lib.rs
+++ b/crates/nu-errors/src/lib.rs
@@ -871,25 +871,25 @@ impl std::error::Error for ShellError {}
 
 impl std::convert::From<Box<dyn std::error::Error>> for ShellError {
     fn from(input: Box<dyn std::error::Error>) -> ShellError {
-        ShellError::untagged_runtime_error(format!("{}", input))
+        ShellError::untagged_runtime_error(input.to_string())
     }
 }
 
 impl std::convert::From<std::io::Error> for ShellError {
     fn from(input: std::io::Error) -> ShellError {
-        ShellError::untagged_runtime_error(format!("{}", input))
+        ShellError::untagged_runtime_error(input.to_string())
     }
 }
 
 impl std::convert::From<std::string::FromUtf8Error> for ShellError {
     fn from(input: std::string::FromUtf8Error) -> ShellError {
-        ShellError::untagged_runtime_error(format!("{}", input))
+        ShellError::untagged_runtime_error(input.to_string())
     }
 }
 
 impl std::convert::From<std::str::Utf8Error> for ShellError {
     fn from(input: std::str::Utf8Error) -> ShellError {
-        ShellError::untagged_runtime_error(format!("{}", input))
+        ShellError::untagged_runtime_error(input.to_string())
     }
 }
 
diff --git a/crates/nu-json/src/de.rs b/crates/nu-json/src/de.rs
index a70ffecc7..430aa68b0 100644
--- a/crates/nu-json/src/de.rs
+++ b/crates/nu-json/src/de.rs
@@ -821,7 +821,7 @@ pub fn from_slice<T>(v: &[u8]) -> Result<T>
 where
     T: de::DeserializeOwned,
 {
-    from_iter(v.iter().map(|byte| Ok(*byte)))
+    from_iter(v.iter().map(|&byte| Ok(byte)))
 }
 
 /// Decodes a Hjson value from a `&str`.
diff --git a/crates/nu-json/src/ser.rs b/crates/nu-json/src/ser.rs
index 74a1728d5..01ea63e86 100644
--- a/crates/nu-json/src/ser.rs
+++ b/crates/nu-json/src/ser.rs
@@ -972,7 +972,7 @@ fn fmt_small<N>(value: N) -> String
 where
     N: Display + LowerExp,
 {
-    let f1 = format!("{}", value);
+    let f1 = value.to_string();
     let f2 = format!("{:e}", value);
     if f1.len() <= f2.len() + 1 {
         f1
diff --git a/crates/nu-json/src/value.rs b/crates/nu-json/src/value.rs
index 7b2744958..0d3533f9c 100644
--- a/crates/nu-json/src/value.rs
+++ b/crates/nu-json/src/value.rs
@@ -144,19 +144,10 @@ impl Value {
     /// a value associated with the provided key is found. If no value is found
     /// or the `Value` is not an Object, returns None.
     pub fn search<'a>(&'a self, key: &str) -> Option<&'a Value> {
-        match *self {
-            Value::Object(ref map) => match map.get(key) {
-                Some(json_value) => Some(json_value),
-                None => {
-                    for (_, v) in map.iter() {
-                        match v.search(key) {
-                            x if x.is_some() => return x,
-                            _ => (),
-                        }
-                    }
-                    None
-                }
-            },
+        match self {
+            Value::Object(map) => map
+                .get(key)
+                .or_else(|| map.values().find_map(|v| v.search(key))),
             _ => None,
         }
     }
@@ -192,8 +183,8 @@ impl Value {
     /// If the `Value` is an Array, returns the associated vector.
     /// Returns None otherwise.
     pub fn as_array(&self) -> Option<&Vec<Value>> {
-        match *self {
-            Value::Array(ref array) => Some(&*array),
+        match self {
+            Value::Array(array) => Some(array),
             _ => None,
         }
     }
@@ -201,8 +192,8 @@ impl Value {
     /// If the `Value` is an Array, returns the associated mutable vector.
     /// Returns None otherwise.
     pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
-        match *self {
-            Value::Array(ref mut list) => Some(list),
+        match self {
+            Value::Array(list) => Some(list),
             _ => None,
         }
     }
@@ -215,30 +206,30 @@ impl Value {
     /// If the `Value` is a String, returns the associated str.
     /// Returns None otherwise.
     pub fn as_str(&self) -> Option<&str> {
-        match *self {
-            Value::String(ref s) => Some(s),
+        match self {
+            Value::String(s) => Some(s),
             _ => None,
         }
     }
 
     /// Returns true if the `Value` is a Number. Returns false otherwise.
     pub fn is_number(&self) -> bool {
-        matches!(*self, Value::I64(_) | Value::U64(_) | Value::F64(_))
+        matches!(self, Value::I64(_) | Value::U64(_) | Value::F64(_))
     }
 
     /// Returns true if the `Value` is a i64. Returns false otherwise.
     pub fn is_i64(&self) -> bool {
-        matches!(*self, Value::I64(_))
+        matches!(self, Value::I64(_))
     }
 
     /// Returns true if the `Value` is a u64. Returns false otherwise.
     pub fn is_u64(&self) -> bool {
-        matches!(*self, Value::U64(_))
+        matches!(self, Value::U64(_))
     }
 
     /// Returns true if the `Value` is a f64. Returns false otherwise.
     pub fn is_f64(&self) -> bool {
-        matches!(*self, Value::F64(_))
+        matches!(self, Value::F64(_))
     }
 
     /// If the `Value` is a number, return or cast it to a i64.
@@ -294,7 +285,7 @@ impl Value {
     /// If the `Value` is a Null, returns ().
     /// Returns None otherwise.
     pub fn as_null(&self) -> Option<()> {
-        match *self {
+        match self {
             Value::Null => Some(()),
             _ => None,
         }
diff --git a/crates/nu-parser/src/flag.rs b/crates/nu-parser/src/flag.rs
index b7686f0d0..8f05abb6b 100644
--- a/crates/nu-parser/src/flag.rs
+++ b/crates/nu-parser/src/flag.rs
@@ -47,7 +47,7 @@ pub fn get_flag_signature_spec(
             let mut starting_pos = arg.span.start() + 1;
             for c in remainder.chars() {
                 let mut found = false;
-                for (full_name, named_arg) in signature.named.iter() {
+                for (full_name, named_arg) in &signature.named {
                     if Some(c) == named_arg.0.get_short() {
                         found = true;
                         output.push((full_name.clone(), named_arg.0.clone()));
diff --git a/crates/nu-parser/src/parse.rs b/crates/nu-parser/src/parse.rs
index 79af9e02b..6bace925d 100644
--- a/crates/nu-parser/src/parse.rs
+++ b/crates/nu-parser/src/parse.rs
@@ -990,7 +990,7 @@ fn parse_arg(
                 SyntaxShape::Table,
                 SyntaxShape::String,
             ];
-            for shape in shapes.iter() {
+            for shape in &shapes {
                 if let (s, None) = parse_arg(*shape, scope, lite_arg) {
                     return (s, None);
                 }
@@ -1740,7 +1740,7 @@ fn expand_aliases_in_call(call: &mut LiteCommand, scope: &dyn ParserScope) {
     if let Some(name) = call.parts.get(0) {
         if let Some(mut expansion) = scope.get_alias(name) {
             // set the expansion's spans to point to the alias itself
-            for item in expansion.iter_mut() {
+            for item in &mut expansion {
                 item.span = name.span;
             }
 
@@ -2065,7 +2065,7 @@ pub fn classify_block(
     let mut error = None;
 
     // Check for custom commands first
-    for group in lite_block.block.iter() {
+    for group in &lite_block.block {
         for pipeline in &group.pipelines {
             for call in &pipeline.commands {
                 if let Some(first) = call.parts.first() {
@@ -2165,7 +2165,7 @@ pub fn classify_block(
     }
 
     let definitions = scope.get_definitions();
-    for definition in definitions.into_iter() {
+    for definition in definitions {
         let name = definition.params.name.clone();
         if !output.definitions.contains_key(&name) {
             output.definitions.insert(name, definition.clone());
@@ -2335,7 +2335,7 @@ fn unit_parse_byte_units() {
         },
     ];
 
-    for case in cases.iter() {
+    for case in &cases {
         let input_len = case.string.len();
         let value_len = case.value.to_string().len();
         let input = case.string.clone().spanned(Span::new(0, input_len));
@@ -2423,7 +2423,7 @@ fn unit_parse_byte_units_decimal() {
         },
     ];
 
-    for case in cases.iter() {
+    for case in &cases {
         let input_len = case.string.len();
         let value_len = case.value_str.to_string().len();
         let input = case.string.clone().spanned(Span::new(0, input_len));
diff --git a/crates/nu-parser/src/parse/def/signature.rs b/crates/nu-parser/src/parse/def/signature.rs
index 446160a19..580515b0d 100644
--- a/crates/nu-parser/src/parse/def/signature.rs
+++ b/crates/nu-parser/src/parse/def/signature.rs
@@ -356,13 +356,13 @@ fn to_signature(
 ) -> Signature {
     let mut sign = Signature::new(name);
 
-    for param in params.into_iter() {
+    for param in params {
         // pub positional: Vec<(PositionalType, Description)>,
         sign.positional
             .push((param.pos_type, param.desc.unwrap_or_else(|| "".to_string())));
     }
 
-    for flag in flags.into_iter() {
+    for flag in flags {
         sign.named.insert(
             flag.long_name,
             (flag.named_type, flag.desc.unwrap_or_else(|| "".to_string())),
diff --git a/crates/nu-parser/src/shapes.rs b/crates/nu-parser/src/shapes.rs
index 82968b032..4a638b3a0 100644
--- a/crates/nu-parser/src/shapes.rs
+++ b/crates/nu-parser/src/shapes.rs
@@ -11,14 +11,14 @@ pub fn expression_to_flat_shape(e: &SpannedExpression) -> Vec<Spanned<FlatShape>
         Expression::Garbage => vec![FlatShape::Garbage.spanned(e.span)],
         Expression::List(exprs) => {
             let mut output = vec![];
-            for expr in exprs.iter() {
+            for expr in exprs {
                 output.append(&mut expression_to_flat_shape(expr));
             }
             output
         }
         Expression::Table(headers, cells) => {
             let mut output = vec![];
-            for header in headers.iter() {
+            for header in headers {
                 output.append(&mut expression_to_flat_shape(header));
             }
             for row in cells {
@@ -31,7 +31,7 @@ pub fn expression_to_flat_shape(e: &SpannedExpression) -> Vec<Spanned<FlatShape>
         Expression::FullColumnPath(exprs) => {
             let mut output = vec![];
             output.append(&mut expression_to_flat_shape(&exprs.head));
-            for member in exprs.tail.iter() {
+            for member in &exprs.tail {
                 if let UnspannedPathMember::String(_) = &member.unspanned {
                     output.push(FlatShape::StringMember.spanned(member.span));
                 }
@@ -102,7 +102,7 @@ pub fn shapes(commands: &Block) -> Vec<Spanned<FlatShape>> {
                         }
 
                         if let Some(named) = &internal.args.named {
-                            for (_, named_arg) in named.iter() {
+                            for (_, named_arg) in named {
                                 match named_arg {
                                     NamedValue::PresentSwitch(span) => {
                                         output.push(FlatShape::Flag.spanned(*span));
@@ -129,7 +129,7 @@ pub fn shapes(commands: &Block) -> Vec<Spanned<FlatShape>> {
                         }
 
                         if let Some(named) = &call.named {
-                            for (_, named_arg) in named.iter() {
+                            for (_, named_arg) in named {
                                 match named_arg {
                                     NamedValue::PresentSwitch(span) => {
                                         output.push(FlatShape::Flag.spanned(*span));
diff --git a/crates/nu-pretty-hex/src/pretty_hex.rs b/crates/nu-pretty-hex/src/pretty_hex.rs
index a025510c2..99ebaf022 100644
--- a/crates/nu-pretty-hex/src/pretty_hex.rs
+++ b/crates/nu-pretty-hex/src/pretty_hex.rs
@@ -169,7 +169,7 @@ where
         .iter()
         .skip(skip)
         .take(amount)
-        .map(|x| *x as u8)
+        .map(|&x| x as u8)
         .collect();
 
     if cfg.title {
diff --git a/crates/nu-pretty-hex/tests/tests.rs b/crates/nu-pretty-hex/tests/tests.rs
index fe1ed8ac6..44691f1e7 100644
--- a/crates/nu-pretty-hex/tests/tests.rs
+++ b/crates/nu-pretty-hex/tests/tests.rs
@@ -14,7 +14,7 @@ fn test_simple() {
     let bytes: Vec<u8> = (0..16).collect();
     let expected = "00 01 02 03  04 05 06 07  08 09 0a 0b  0c 0d 0e 0f";
     assert_eq!(expected, simple_hex(&bytes));
-    assert_eq!(expected, format!("{}", bytes.hex_dump()));
+    assert_eq!(expected, bytes.hex_dump().to_string());
     assert_eq!(simple_hex(&bytes), config_hex(&bytes, HexConfig::simple()));
 
     let mut have = String::new();
@@ -149,7 +149,7 @@ fn test_config() {
          0010:   10 11 12                                          ..."
     );
     assert_eq!(
-        format!("{}", v.hex_conf(cfg)),
+        v.hex_conf(cfg).to_string(),
         "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12"
     );
 }
diff --git a/crates/nu-protocol/src/dataframe/compute_between.rs b/crates/nu-protocol/src/dataframe/compute_between.rs
index 9ebfc4039..627b71eaf 100644
--- a/crates/nu-protocol/src/dataframe/compute_between.rs
+++ b/crates/nu-protocol/src/dataframe/compute_between.rs
@@ -88,7 +88,7 @@ pub fn between_dataframes(
             Ok(df) => Ok(df.into_untagged()),
             Err(e) => Ok(UntaggedValue::Error(ShellError::labeled_error(
                 "Appending error",
-                format!("{}", e),
+                e.to_string(),
                 operation_span,
             ))),
         },
@@ -110,19 +110,19 @@ pub fn compute_between_series(
         Operator::Plus => {
             let mut res = lhs + rhs;
             let name = format!("sum_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::Minus => {
             let mut res = lhs - rhs;
             let name = format!("sub_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::Multiply => {
             let mut res = lhs * rhs;
             let name = format!("mul_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::Divide => {
@@ -130,12 +130,12 @@ pub fn compute_between_series(
             match res {
                 Ok(mut res) => {
                     let name = format!("div_{}_{}", lhs.name(), rhs.name());
-                    res.rename(name.as_ref());
+                    res.rename(&name);
                     Ok(NuDataFrame::series_to_untagged(res, operation_span))
                 }
                 Err(e) => Ok(UntaggedValue::Error(ShellError::labeled_error(
                     "Division error",
-                    format!("{}", e),
+                    e.to_string(),
                     operation_span,
                 ))),
             }
@@ -143,37 +143,37 @@ pub fn compute_between_series(
         Operator::Equal => {
             let mut res = Series::eq(lhs, rhs).into_series();
             let name = format!("eq_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::NotEqual => {
             let mut res = Series::neq(lhs, rhs).into_series();
             let name = format!("neq_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::LessThan => {
             let mut res = Series::lt(lhs, rhs).into_series();
             let name = format!("lt_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::LessThanOrEqual => {
             let mut res = Series::lt_eq(lhs, rhs).into_series();
             let name = format!("lte_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::GreaterThan => {
             let mut res = Series::gt(lhs, rhs).into_series();
             let name = format!("gt_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::GreaterThanOrEqual => {
             let mut res = Series::gt_eq(lhs, rhs).into_series();
             let name = format!("gte_{}_{}", lhs.name(), rhs.name());
-            res.rename(name.as_ref());
+            res.rename(&name);
             Ok(NuDataFrame::series_to_untagged(res, operation_span))
         }
         Operator::And => match lhs.dtype() {
@@ -185,7 +185,7 @@ pub fn compute_between_series(
                     (Ok(l), Ok(r)) => {
                         let mut res = l.bitand(r).into_series();
                         let name = format!("and_{}_{}", lhs.name(), rhs.name());
-                        res.rename(name.as_ref());
+                        res.rename(&name);
                         Ok(NuDataFrame::series_to_untagged(res, operation_span))
                     }
                     _ => Ok(UntaggedValue::Error(ShellError::labeled_error(
@@ -210,7 +210,7 @@ pub fn compute_between_series(
                     (Ok(l), Ok(r)) => {
                         let mut res = l.bitor(r).into_series();
                         let name = format!("or_{}_{}", lhs.name(), rhs.name());
-                        res.rename(name.as_ref());
+                        res.rename(&name);
                         Ok(NuDataFrame::series_to_untagged(res, operation_span))
                     }
                     _ => Ok(UntaggedValue::Error(ShellError::labeled_error(
@@ -612,7 +612,7 @@ where
                 }
                 Err(e) => UntaggedValue::Error(ShellError::labeled_error(
                     "Casting error",
-                    format!("{}", e),
+                    e.to_string(),
                     span,
                 )),
             }
@@ -649,7 +649,7 @@ where
         }
         Err(e) => UntaggedValue::Error(ShellError::labeled_error(
             "Casting error",
-            format!("{}", e),
+            e.to_string(),
             span,
         )),
     }
@@ -676,7 +676,7 @@ where
                 }
                 Err(e) => UntaggedValue::Error(ShellError::labeled_error(
                     "Casting error",
-                    format!("{}", e),
+                    e.to_string(),
                     span,
                 )),
             }
@@ -719,7 +719,7 @@ where
         }
         Err(e) => UntaggedValue::Error(ShellError::labeled_error(
             "Casting error",
-            format!("{}", e),
+            e.to_string(),
             span,
         )),
     }
@@ -740,7 +740,7 @@ where
                 }
                 Err(e) => UntaggedValue::Error(ShellError::labeled_error(
                     "Casting error",
-                    format!("{}", e),
+                    e.to_string(),
                     span,
                 )),
             }
@@ -777,7 +777,7 @@ where
         }
         Err(e) => UntaggedValue::Error(ShellError::labeled_error(
             "Casting error",
-            format!("{}", e),
+            e.to_string(),
             span,
         )),
     }
@@ -804,7 +804,7 @@ where
                 }
                 Err(e) => UntaggedValue::Error(ShellError::labeled_error(
                     "Casting error",
-                    format!("{}", e),
+                    e.to_string(),
                     span,
                 )),
             }
@@ -847,7 +847,7 @@ where
         }
         Err(e) => UntaggedValue::Error(ShellError::labeled_error(
             "Casting error",
-            format!("{}", e),
+            e.to_string(),
             span,
         )),
     }
@@ -866,14 +866,14 @@ fn contains_series_pat(series: &Series, pat: &str, span: &Span) -> UntaggedValue
                 }
                 Err(e) => UntaggedValue::Error(ShellError::labeled_error(
                     "Search error",
-                    format!("{}", e),
+                    e.to_string(),
                     span,
                 )),
             }
         }
         Err(e) => UntaggedValue::Error(ShellError::labeled_error(
             "Casting error",
-            format!("{}", e),
+            e.to_string(),
             span,
         )),
     }
diff --git a/crates/nu-protocol/src/dataframe/conversion.rs b/crates/nu-protocol/src/dataframe/conversion.rs
index 106219315..a3b8263a2 100644
--- a/crates/nu-protocol/src/dataframe/conversion.rs
+++ b/crates/nu-protocol/src/dataframe/conversion.rs
@@ -498,7 +498,7 @@ pub fn insert_row(column_values: &mut ColumnMap, dictionary: Dictionary) -> Resu
 // The names for the columns are the enumerated numbers from the values
 pub fn insert_table(column_values: &mut ColumnMap, table: Vec<Value>) -> Result<(), ShellError> {
     for (index, value) in table.into_iter().enumerate() {
-        let key = format!("{}", index);
+        let key = index.to_string();
         insert_value(value, key, column_values)?;
     }
 
@@ -617,7 +617,7 @@ pub fn from_parsed_columns(
                     let mut builder =
                         ObjectChunkedBuilder::<Value>::new(&name, column.values.len());
 
-                    for v in column.values.iter() {
+                    for v in &column.values {
                         builder.append_value(v.clone());
                     }
 
@@ -658,12 +658,10 @@ pub fn from_parsed_columns(
 
     match df {
         Ok(df) => Ok(NuDataFrame::new(df)),
-        Err(e) => {
-            return Err(ShellError::labeled_error(
-                "Error while creating dataframe",
-                format!("{}", e),
-                span,
-            ))
-        }
+        Err(e) => Err(ShellError::labeled_error(
+            "Error while creating dataframe",
+            e.to_string(),
+            span,
+        )),
     }
 }
diff --git a/crates/nu-protocol/src/dataframe/nu_dataframe.rs b/crates/nu-protocol/src/dataframe/nu_dataframe.rs
index 736b9774d..e3d828885 100644
--- a/crates/nu-protocol/src/dataframe/nu_dataframe.rs
+++ b/crates/nu-protocol/src/dataframe/nu_dataframe.rs
@@ -176,7 +176,7 @@ impl NuDataFrame {
                 | UntaggedValue::Primitive(Primitive::Boolean(_))
                 | UntaggedValue::Primitive(Primitive::Date(_))
                 | UntaggedValue::DataFrame(_) => {
-                    let key = format!("{}", 0);
+                    let key = "0".to_string();
                     insert_value(value, key, &mut column_values)?
                 }
                 _ => {
@@ -211,7 +211,7 @@ impl NuDataFrame {
 
         for column in columns {
             let name = column.name().to_string();
-            for value in column.into_iter() {
+            for value in column {
                 insert_value(value, name.clone(), &mut column_values)?;
             }
         }
@@ -253,13 +253,13 @@ impl NuDataFrame {
     }
 
     pub fn column(&self, column: &str, tag: &Tag) -> Result<Self, ShellError> {
-        let s = self.as_ref().column(column).map_err(|e| {
-            ShellError::labeled_error("Column not found", format!("{}", e), tag.span)
-        })?;
+        let s = self
+            .as_ref()
+            .column(column)
+            .map_err(|e| ShellError::labeled_error("Column not found", e.to_string(), tag.span))?;
 
-        let dataframe = DataFrame::new(vec![s.clone()]).map_err(|e| {
-            ShellError::labeled_error("DataFrame error", format!("{}", e), tag.span)
-        })?;
+        let dataframe = DataFrame::new(vec![s.clone()])
+            .map_err(|e| ShellError::labeled_error("DataFrame error", e.to_string(), tag.span))?;
 
         Ok(Self { dataframe })
     }
@@ -375,7 +375,7 @@ impl NuDataFrame {
             .map(|i| {
                 let mut dictionary_row = Dictionary::default();
 
-                for (name, col) in iterators.iter_mut() {
+                for (name, col) in &mut iterators {
                     let dict_val = match col.next() {
                         Some(v) => v,
                         None => {
diff --git a/crates/nu-protocol/src/dataframe/nu_groupby.rs b/crates/nu-protocol/src/dataframe/nu_groupby.rs
index c5439b88b..4f47295f9 100644
--- a/crates/nu-protocol/src/dataframe/nu_groupby.rs
+++ b/crates/nu-protocol/src/dataframe/nu_groupby.rs
@@ -50,7 +50,7 @@ impl NuGroupBy {
         let df = self.dataframe.as_ref();
 
         let by = df.select_series(&self.by).map_err(|e| {
-            ShellError::labeled_error("Error creating groupby", format!("{}", e), Tag::unknown())
+            ShellError::labeled_error("Error creating groupby", e.to_string(), Tag::unknown())
         })?;
 
         Ok(GroupBy::new(df, by, self.groups.clone(), None))
diff --git a/crates/nu-protocol/src/dataframe/operations.rs b/crates/nu-protocol/src/dataframe/operations.rs
index 9140d9474..8426f1464 100644
--- a/crates/nu-protocol/src/dataframe/operations.rs
+++ b/crates/nu-protocol/src/dataframe/operations.rs
@@ -40,7 +40,7 @@ impl NuDataFrame {
                     .as_ref()
                     .get_columns()
                     .iter()
-                    .chain(other.as_ref().get_columns().iter())
+                    .chain(other.as_ref().get_columns())
                     .map(|s| {
                         let name = if columns.contains(&s.name()) {
                             format!("{}_{}", s.name(), "x")
@@ -50,13 +50,13 @@ impl NuDataFrame {
                         };
 
                         let mut series = s.clone();
-                        series.rename(name.as_str());
+                        series.rename(&name);
                         series
                     })
                     .collect::<Vec<Series>>();
 
                 let df_new = DataFrame::new(new_cols).map_err(|e| {
-                    ShellError::labeled_error("Appending error", format!("{}", e), span)
+                    ShellError::labeled_error("Appending error", e.to_string(), span)
                 })?;
 
                 Ok(NuDataFrame::new(df_new))
@@ -110,7 +110,7 @@ impl NuDataFrame {
                     .collect::<Result<Vec<Series>, ShellError>>()?;
 
                 let df_new = DataFrame::new(new_cols).map_err(|e| {
-                    ShellError::labeled_error("Appending error", format!("{}", e), span)
+                    ShellError::labeled_error("Appending error", e.to_string(), span)
                 })?;
 
                 Ok(NuDataFrame::new(df_new))
diff --git a/crates/nu-protocol/src/hir.rs b/crates/nu-protocol/src/hir.rs
index a5d53aa92..485a187db 100644
--- a/crates/nu-protocol/src/hir.rs
+++ b/crates/nu-protocol/src/hir.rs
@@ -3,6 +3,7 @@ use std::hash::{Hash, Hasher};
 use std::path::PathBuf;
 use std::{convert::From, sync::Arc};
 
+use indexmap::map::Iter;
 use serde::{Deserialize, Serialize};
 
 use crate::Signature;
@@ -384,7 +385,7 @@ impl PrettyDebugWithSource for Member {
     fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
         match self {
             Member::String(outer, _) => DbgDocBldr::value(outer.slice(source)),
-            Member::Int(int, _) => DbgDocBldr::value(format!("{}", int)),
+            Member::Int(int, _) => DbgDocBldr::value(int),
             Member::Bare(span) => DbgDocBldr::value(span.span.slice(source)),
         }
     }
@@ -786,13 +787,10 @@ impl PrettyDebugWithSource for SpannedExpression {
                 Expression::Table(_headers, cells) => DbgDocBldr::delimit(
                     "[",
                     DbgDocBldr::intersperse(
-                        cells
-                            .iter()
-                            .map(|row| {
-                                row.iter()
-                                    .map(|item| item.refined_pretty_debug(refine, source))
-                            })
-                            .flatten(),
+                        cells.iter().flat_map(|row| {
+                            row.iter()
+                                .map(|item| item.refined_pretty_debug(refine, source))
+                        }),
                         DbgDocBldr::space(),
                     ),
                     "]",
@@ -846,8 +844,7 @@ impl PrettyDebugWithSource for SpannedExpression {
                 DbgDocBldr::intersperse(
                     cells
                         .iter()
-                        .map(|row| row.iter().map(|item| item.pretty_debug(source)))
-                        .flatten(),
+                        .flat_map(|row| row.iter().map(|item| item.pretty_debug(source))),
                     DbgDocBldr::space(),
                 ),
                 "]",
@@ -1014,7 +1011,7 @@ impl PrettyDebugWithSource for SpannedLiteral {
                 Literal::String(string) => DbgDocBldr::primitive(format!("{:?}", string)), //string.slice(source))),
                 Literal::GlobPattern(pattern) => DbgDocBldr::primitive(pattern),
                 Literal::ColumnPath(path) => {
-                    DbgDocBldr::intersperse_with_source(path.iter(), DbgDocBldr::space(), source)
+                    DbgDocBldr::intersperse_with_source(path, DbgDocBldr::space(), source)
                 }
                 Literal::Bare(bare) => {
                     DbgDocBldr::delimit("b\"", DbgDocBldr::primitive(bare), "\"")
@@ -1039,7 +1036,7 @@ impl PrettyDebugWithSource for SpannedLiteral {
             }
             Literal::ColumnPath(path) => DbgDocBldr::typed(
                 "column path",
-                DbgDocBldr::intersperse_with_source(path.iter(), DbgDocBldr::space(), source),
+                DbgDocBldr::intersperse_with_source(path, DbgDocBldr::space(), source),
             ),
             Literal::Bare(bare) => DbgDocBldr::typed("bare", DbgDocBldr::primitive(bare)),
             Literal::Operator(operator) => {
@@ -1359,7 +1356,7 @@ impl Call {
     }
 
     pub fn set_initial_flags(&mut self, signature: &crate::Signature) {
-        for (named, value) in signature.named.iter() {
+        for (named, value) in &signature.named {
             if self.named.is_none() {
                 self.named = Some(NamedArguments::new());
             }
@@ -1570,7 +1567,7 @@ impl NamedArguments {
 
     pub fn get_free_variables(&self, known_variables: &mut Vec<String>) -> Vec<String> {
         let mut free_variables = vec![];
-        for (_, val) in self.named.iter() {
+        for (_, val) in &self.named {
             free_variables.extend(val.get_free_variables(known_variables));
         }
         free_variables
@@ -1646,6 +1643,16 @@ impl PrettyDebugWithSource for NamedArguments {
     }
 }
 
+impl<'a> IntoIterator for &'a NamedArguments {
+    type Item = (&'a String, &'a NamedValue);
+
+    type IntoIter = Iter<'a, String, NamedValue>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.named.iter()
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum FlagKind {
     Shorthand,
diff --git a/crates/nu-protocol/src/type_shape.rs b/crates/nu-protocol/src/type_shape.rs
index 497984c02..3f4eaa60d 100644
--- a/crates/nu-protocol/src/type_shape.rs
+++ b/crates/nu-protocol/src/type_shape.rs
@@ -167,7 +167,7 @@ impl Type {
     pub fn from_dictionary(dictionary: &Dictionary) -> Type {
         let mut map = IndexMap::new();
 
-        for (key, value) in dictionary.entries.iter() {
+        for (key, value) in &dictionary.entries {
             let column = Column::String(key.clone());
             map.insert(column, Type::from_value(value));
         }
@@ -179,7 +179,7 @@ impl Type {
     pub fn from_table<'a>(table: impl IntoIterator<Item = &'a Value>) -> Type {
         let mut vec = vec![];
 
-        for item in table.into_iter() {
+        for item in table {
             vec.push(Type::from_value(item))
         }
 
@@ -191,7 +191,7 @@ impl Type {
         match value.into() {
             UntaggedValue::Primitive(p) => Type::from_primitive(p),
             UntaggedValue::Row(row) => Type::from_dictionary(row),
-            UntaggedValue::Table(table) => Type::from_table(table.iter()),
+            UntaggedValue::Table(table) => Type::from_table(table),
             UntaggedValue::Error(_) => Type::Error,
             UntaggedValue::Block(_) => Type::Block,
             #[cfg(feature = "dataframe")]
@@ -328,7 +328,7 @@ impl<'a> PrettyDebug for DebugEntry<'a> {
 
 /// Helper to create a pretty-print for the type
 fn ty(name: impl std::fmt::Display) -> DebugDocBuilder {
-    DbgDocBldr::kind(format!("{}", name))
+    DbgDocBldr::kind(name)
 }
 
 pub trait GroupedValue: Debug + Clone {
diff --git a/crates/nu-protocol/src/value.rs b/crates/nu-protocol/src/value.rs
index c21541436..cc8e62cae 100644
--- a/crates/nu-protocol/src/value.rs
+++ b/crates/nu-protocol/src/value.rs
@@ -401,11 +401,11 @@ impl Value {
         match &self.value {
             UntaggedValue::Primitive(Primitive::String(s)) => s.clone(),
             UntaggedValue::Primitive(Primitive::Date(dt)) => dt.format("%Y-%m-%d").to_string(),
-            UntaggedValue::Primitive(Primitive::Boolean(x)) => format!("{}", x),
-            UntaggedValue::Primitive(Primitive::Decimal(x)) => format!("{}", x),
-            UntaggedValue::Primitive(Primitive::Int(x)) => format!("{}", x),
-            UntaggedValue::Primitive(Primitive::Filesize(x)) => format!("{}", x),
-            UntaggedValue::Primitive(Primitive::FilePath(x)) => format!("{}", x.display()),
+            UntaggedValue::Primitive(Primitive::Boolean(x)) => x.to_string(),
+            UntaggedValue::Primitive(Primitive::Decimal(x)) => x.to_string(),
+            UntaggedValue::Primitive(Primitive::Int(x)) => x.to_string(),
+            UntaggedValue::Primitive(Primitive::Filesize(x)) => x.to_string(),
+            UntaggedValue::Primitive(Primitive::FilePath(x)) => x.display().to_string(),
             UntaggedValue::Primitive(Primitive::ColumnPath(path)) => {
                 let joined: String = path
                     .iter()
diff --git a/crates/nu-protocol/src/value/column_path.rs b/crates/nu-protocol/src/value/column_path.rs
index a352dad95..53121f496 100644
--- a/crates/nu-protocol/src/value/column_path.rs
+++ b/crates/nu-protocol/src/value/column_path.rs
@@ -38,7 +38,7 @@ impl PrettyDebug for &PathMember {
     fn pretty(&self) -> DebugDocBuilder {
         match &self.unspanned {
             UnspannedPathMember::String(string) => DbgDocBldr::primitive(format!("{:?}", string)),
-            UnspannedPathMember::Int(int) => DbgDocBldr::primitive(format!("{}", int)),
+            UnspannedPathMember::Int(int) => DbgDocBldr::primitive(int),
         }
     }
 }
@@ -170,6 +170,16 @@ impl HasFallibleSpan for ColumnPath {
     }
 }
 
+impl<'a> IntoIterator for &'a ColumnPath {
+    type Item = &'a PathMember;
+
+    type IntoIter = std::slice::Iter<'a, PathMember>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.members.iter()
+    }
+}
+
 impl PathMember {
     /// Create a string path member
     pub fn string(string: impl Into<String>, span: impl Into<Span>) -> PathMember {
@@ -184,7 +194,7 @@ impl PathMember {
     pub fn as_string(&self) -> String {
         match &self.unspanned {
             UnspannedPathMember::String(string) => string.clone(),
-            UnspannedPathMember::Int(int) => format!("{}", int),
+            UnspannedPathMember::Int(int) => int.to_string(),
         }
     }
 }
diff --git a/crates/nu-protocol/src/value/primitive.rs b/crates/nu-protocol/src/value/primitive.rs
index 4186e0224..c40c86685 100644
--- a/crates/nu-protocol/src/value/primitive.rs
+++ b/crates/nu-protocol/src/value/primitive.rs
@@ -90,14 +90,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_usize().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::U64,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into an unsigned 64-bit integer",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_usize().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::U64,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into an unsigned 64-bit integer",
                 )
             }),
@@ -114,14 +114,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_u64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::U64,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into an unsigned 64-bit integer",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_u64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::U64,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into an unsigned 64-bit integer",
                 )
             }),
@@ -138,14 +138,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_f64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::F64,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into a 64-bit floating point",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_f64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::F64,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into a 64-bit floating point",
                 )
             }),
@@ -162,21 +162,21 @@ impl Primitive {
             Primitive::Int(int) => int.to_i64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I64,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into a signed 64-bit integer",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_i64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I64,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into a signed 64-bit integer",
                 )
             }),
             Primitive::Duration(duration) => duration.to_i64().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I64,
-                    &format!("{}", duration).spanned(span),
+                    &duration.to_string().spanned(span),
                     "converting a duration into a signed 64-bit integer",
                 )
             }),
@@ -193,14 +193,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_u32().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::U32,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into a unsigned 32-bit integer",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_u32().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::U32,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into a unsigned 32-bit integer",
                 )
             }),
@@ -216,14 +216,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_i32().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I32,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into a signed 32-bit integer",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_i32().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I32,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into a signed 32-bit integer",
                 )
             }),
@@ -239,14 +239,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_i16().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I16,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into a signed 16-bit integer",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_i16().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::I16,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into a signed 16-bit integer",
                 )
             }),
@@ -262,14 +262,14 @@ impl Primitive {
             Primitive::Int(int) => int.to_f32().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::F32,
-                    &format!("{}", int).spanned(span),
+                    &int.to_string().spanned(span),
                     "converting an integer into a signed 32-bit float",
                 )
             }),
             Primitive::Decimal(decimal) => decimal.to_f32().ok_or_else(|| {
                 ShellError::range_error(
                     ExpectedRange::F32,
-                    &format!("{}", decimal).spanned(span),
+                    &decimal.to_string().spanned(span),
                     "converting a decimal into a signed 32-bit float",
                 )
             }),
@@ -460,7 +460,7 @@ pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> S
         Primitive::Nothing => String::new(),
         Primitive::BeginningOfStream => String::new(),
         Primitive::EndOfStream => String::new(),
-        Primitive::FilePath(p) => format!("{}", p.display()),
+        Primitive::FilePath(p) => p.display().to_string(),
         Primitive::Filesize(num_bytes) => {
             if let Some(value) = num_bytes.to_u128() {
                 let byte = byte_unit::Byte::from_bytes(value);
@@ -489,7 +489,7 @@ pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> S
             if decimal_places.len() == 2 && decimal_places[1].len() > 4 {
                 format!("{:.4}", decimal)
             } else {
-                format!("{}", decimal)
+                decimal.to_string()
             }
         }
         Primitive::Range(range) => format!(
@@ -595,5 +595,5 @@ pub fn format_duration(duration: &BigInt) -> String {
 
 /// Format a date value into a humanized string (eg "1 week ago" instead of a formal date string)
 pub fn format_date(d: &DateTime<FixedOffset>) -> String {
-    format!("{}", HumanTime::from(*d))
+    HumanTime::from(*d).to_string()
 }
diff --git a/crates/nu-serde/src/lib.rs b/crates/nu-serde/src/lib.rs
index 977d08001..e07a62c26 100644
--- a/crates/nu-serde/src/lib.rs
+++ b/crates/nu-serde/src/lib.rs
@@ -73,7 +73,7 @@ impl serde::ser::Error for Error {
     where
         T: std::fmt::Display,
     {
-        Self::SerdeCustom(format!("{}", msg))
+        Self::SerdeCustom(msg.to_string())
     }
 }
 
diff --git a/crates/nu-source/src/pretty.rs b/crates/nu-source/src/pretty.rs
index ff7fed1cc..170b4383f 100644
--- a/crates/nu-source/src/pretty.rs
+++ b/crates/nu-source/src/pretty.rs
@@ -182,9 +182,8 @@ impl DebugDocBuilder {
     ) -> DebugDocBuilder {
         DbgDocBldr::delimit(
             "(",
-            (DbgDocBldr::kind(kind)
-                + DbgDocBldr::delimit("[", DbgDocBldr::kind(format!("{}", subkind)), "]"))
-            .group()
+            (DbgDocBldr::kind(kind) + DbgDocBldr::delimit("[", DbgDocBldr::kind(subkind), "]"))
+                .group()
                 + DbgDocBldr::space()
                 + value.group(),
             ")",
@@ -205,7 +204,7 @@ impl DebugDocBuilder {
     }
 
     pub fn primitive(string: impl std::fmt::Display) -> DebugDocBuilder {
-        DebugDocBuilder::styled(format!("{}", string), ShellStyle::Primitive)
+        DebugDocBuilder::styled(string, ShellStyle::Primitive)
     }
 
     pub fn opaque(string: impl std::fmt::Display) -> DebugDocBuilder {
@@ -501,17 +500,17 @@ fn hash_doc<H: std::hash::Hasher>(doc: &PrettyDebugDoc, state: &mut H) {
         pretty::Doc::Nil => 0u8.hash(state),
         pretty::Doc::Append(a, b) => {
             1u8.hash(state);
-            hash_doc(&*a, state);
-            hash_doc(&*b, state);
+            hash_doc(a, state);
+            hash_doc(b, state);
         }
         pretty::Doc::Group(a) => {
             2u8.hash(state);
-            hash_doc(&*a, state);
+            hash_doc(a, state);
         }
         pretty::Doc::Nest(a, b) => {
             3u8.hash(state);
             a.hash(state);
-            hash_doc(&*b, state);
+            hash_doc(b, state);
         }
         pretty::Doc::Space => 4u8.hash(state),
         pretty::Doc::Newline => 5u8.hash(state),
@@ -522,7 +521,7 @@ fn hash_doc<H: std::hash::Hasher>(doc: &PrettyDebugDoc, state: &mut H) {
         pretty::Doc::Annotated(a, b) => {
             7u8.hash(state);
             a.hash(state);
-            hash_doc(&*b, state);
+            hash_doc(b, state);
         }
     }
 }
diff --git a/crates/nu-table/src/main.rs b/crates/nu-table/src/main.rs
index 16c214db9..638582a1f 100644
--- a/crates/nu-table/src/main.rs
+++ b/crates/nu-table/src/main.rs
@@ -72,7 +72,7 @@ fn make_table_data() -> (Vec<&'static str>, Vec<&'static str>) {
 fn vec_of_str_to_vec_of_styledstr(data: &[&str], is_header: bool) -> Vec<StyledString> {
     let mut v = vec![];
 
-    for x in data.iter() {
+    for x in data {
         if is_header {
             v.push(StyledString::new(
                 String::from(*x),
diff --git a/crates/nu-table/src/table.rs b/crates/nu-table/src/table.rs
index 7913f59ac..817c59ef9 100644
--- a/crates/nu-table/src/table.rs
+++ b/crates/nu-table/src/table.rs
@@ -1,6 +1,7 @@
 use crate::wrap::{column_width, split_sublines, wrap, Alignment, Subline, WrappedCell};
 use nu_ansi_term::{Color, Style};
 use std::collections::HashMap;
+use std::fmt::Write;
 
 enum SeparatorPosition {
     Top,
@@ -862,12 +863,12 @@ impl WrappedTable {
                     );
                 }
             }
+
             if lines_printed == 0 {
                 break;
-            } else {
-                total_output.push_str(output.as_str());
-                total_output.push('\n');
             }
+
+            writeln!(&mut total_output, "{}", output).unwrap();
         }
         total_output
     }
@@ -885,17 +886,14 @@ impl WrappedTable {
         }
 
         if self.theme.print_top_border {
-            output.push_str(
-                self.print_separator(SeparatorPosition::Top, color_hm)
-                    .as_str(),
-            );
+            output.push_str(&self.print_separator(SeparatorPosition::Top, color_hm));
         }
 
         let skip_headers = (self.headers.len() == 2 && self.headers[1].max_width == 0)
             || (self.headers.len() == 1 && self.headers[0].max_width == 0);
 
         if !self.headers.is_empty() && !skip_headers {
-            output.push_str(self.print_cell_contents(&self.headers, color_hm).as_str());
+            output.push_str(&self.print_cell_contents(&self.headers, color_hm));
         }
 
         let mut first_row = true;
@@ -903,31 +901,23 @@ impl WrappedTable {
         for row in &self.data {
             if !first_row {
                 if self.theme.separate_rows {
-                    output.push_str(
-                        self.print_separator(SeparatorPosition::Middle, color_hm)
-                            .as_str(),
-                    )
+                    output.push_str(&self.print_separator(SeparatorPosition::Middle, color_hm));
                 }
             } else {
                 first_row = false;
 
                 if self.theme.separate_header && !self.headers.is_empty() && !skip_headers {
-                    output.push_str(
-                        self.print_separator(SeparatorPosition::Middle, color_hm)
-                            .as_str(),
-                    );
+                    output.push_str(&self.print_separator(SeparatorPosition::Middle, color_hm));
                 }
             }
 
-            output.push_str(self.print_cell_contents(row, color_hm).as_str());
+            output.push_str(&self.print_cell_contents(row, color_hm));
         }
 
         if self.theme.print_bottom_border {
-            output.push_str(
-                self.print_separator(SeparatorPosition::Bottom, color_hm)
-                    .as_str(),
-            );
+            output.push_str(&self.print_separator(SeparatorPosition::Bottom, color_hm));
         }
+
         output
     }
 }
diff --git a/crates/nu-test-support/src/macros.rs b/crates/nu-test-support/src/macros.rs
index f7f0951a0..268148405 100644
--- a/crates/nu-test-support/src/macros.rs
+++ b/crates/nu-test-support/src/macros.rs
@@ -41,7 +41,7 @@ macro_rules! nu {
         let mut paths = $crate::shell_os_paths();
         paths.insert(0, test_bins);
 
-        let paths_joined = match std::env::join_paths(paths.iter()) {
+        let paths_joined = match std::env::join_paths(paths) {
             Ok(all) => all,
             Err(_) => panic!("Couldn't join paths for PATH var."),
         };
@@ -122,7 +122,7 @@ macro_rules! nu_with_plugins {
         let mut paths = $crate::shell_os_paths();
         paths.insert(0, test_bins);
 
-        let paths_joined = match std::env::join_paths(paths.iter()) {
+        let paths_joined = match std::env::join_paths(paths) {
             Ok(all) => all,
             Err(_) => panic!("Couldn't join paths for PATH var."),
         };
diff --git a/crates/nu-test-support/src/playground/director.rs b/crates/nu-test-support/src/playground/director.rs
index 59476576a..9074338b7 100644
--- a/crates/nu-test-support/src/playground/director.rs
+++ b/crates/nu-test-support/src/playground/director.rs
@@ -103,7 +103,7 @@ impl Executable for Director {
                 if let Some(pipelines) = &self.pipeline {
                     let child = process.stdin.as_mut().expect("Failed to open stdin");
 
-                    for pipeline in pipelines.iter() {
+                    for pipeline in pipelines {
                         child
                             .write_all(format!("{}\n", pipeline).as_bytes())
                             .expect("Could not write to");
diff --git a/crates/nu-test-support/src/playground/nu_process.rs b/crates/nu-test-support/src/playground/nu_process.rs
index 30e18141e..90378d270 100644
--- a/crates/nu-test-support/src/playground/nu_process.rs
+++ b/crates/nu-test-support/src/playground/nu_process.rs
@@ -94,7 +94,7 @@ impl NuProcess {
 
         let paths = vec![test_bins_path()];
 
-        let paths_joined = match std::env::join_paths(paths.iter()) {
+        let paths_joined = match std::env::join_paths(&paths) {
             Ok(all) => all,
             Err(_) => panic!("Couldn't join paths for PATH var."),
         };
diff --git a/crates/nu-value-ext/src/lib.rs b/crates/nu-value-ext/src/lib.rs
index 331ddf5a7..144c3d8b6 100644
--- a/crates/nu-value-ext/src/lib.rs
+++ b/crates/nu-value-ext/src/lib.rs
@@ -206,7 +206,7 @@ pub fn get_data_by_member(value: &Value, name: &PathMember) -> Result<Value, She
         UntaggedValue::DataFrame(df) => match &name.unspanned {
             UnspannedPathMember::String(string) => {
                 let column = df.as_ref().select(string.as_str()).map_err(|e| {
-                    ShellError::labeled_error("Dataframe error", format!("{}", e), &name.span)
+                    ShellError::labeled_error("Dataframe error", e.to_string(), &name.span)
                 })?;
 
                 Ok(NuDataFrame::dataframe_to_value(
@@ -243,7 +243,7 @@ where
 {
     let mut current = value.clone();
 
-    for p in path.iter() {
+    for p in path {
         let value = get_data_by_member(&current, p);
 
         match value {
@@ -526,7 +526,7 @@ pub fn forgiving_insert_data_at_column_path(
 
         let mut candidate = new_value;
 
-        for member in paths.iter() {
+        for member in &paths {
             match &member.unspanned {
                 UnspannedPathMember::String(column_name) => {
                     candidate =
@@ -693,16 +693,16 @@ pub fn as_string(value: &Value) -> Result<String, ShellError> {
     match &value.value {
         UntaggedValue::Primitive(Primitive::String(s)) => Ok(s.clone()),
         UntaggedValue::Primitive(Primitive::Date(dt)) => Ok(dt.format("%Y-%m-%d").to_string()),
-        UntaggedValue::Primitive(Primitive::Boolean(x)) => Ok(format!("{}", x)),
-        UntaggedValue::Primitive(Primitive::Decimal(x)) => Ok(format!("{}", x)),
-        UntaggedValue::Primitive(Primitive::Int(x)) => Ok(format!("{}", x)),
-        UntaggedValue::Primitive(Primitive::Filesize(x)) => Ok(format!("{}", x)),
-        UntaggedValue::Primitive(Primitive::FilePath(x)) => Ok(format!("{}", x.display())),
+        UntaggedValue::Primitive(Primitive::Boolean(x)) => Ok(x.to_string()),
+        UntaggedValue::Primitive(Primitive::Decimal(x)) => Ok(x.to_string()),
+        UntaggedValue::Primitive(Primitive::Int(x)) => Ok(x.to_string()),
+        UntaggedValue::Primitive(Primitive::Filesize(x)) => Ok(x.to_string()),
+        UntaggedValue::Primitive(Primitive::FilePath(x)) => Ok(x.display().to_string()),
         UntaggedValue::Primitive(Primitive::ColumnPath(path)) => Ok(path
             .iter()
             .map(|member| match &member.unspanned {
                 UnspannedPathMember::String(name) => name.to_string(),
-                UnspannedPathMember::Int(n) => format!("{}", n),
+                UnspannedPathMember::Int(n) => n.to_string(),
             })
             .join(".")),
 
diff --git a/crates/nu_plugin_chart/src/bar.rs b/crates/nu_plugin_chart/src/bar.rs
index 308eadb82..4a77d0eca 100644
--- a/crates/nu_plugin_chart/src/bar.rs
+++ b/crates/nu_plugin_chart/src/bar.rs
@@ -25,16 +25,10 @@ impl<'a> Bar<'a> {
             .table_entries()
             .cloned()
             .collect::<Vec<_>>()
-            .into_iter()
         {
             let mut percentages_collected = vec![];
 
-            for percentage in percentages
-                .table_entries()
-                .cloned()
-                .collect::<Vec<_>>()
-                .into_iter()
-            {
+            for percentage in percentages.table_entries().cloned().collect::<Vec<_>>() {
                 percentages_collected.push(percentage.as_u64()?);
             }
 
diff --git a/crates/nu_plugin_chart/src/line.rs b/crates/nu_plugin_chart/src/line.rs
index 1b24b4c72..8ed963a55 100644
--- a/crates/nu_plugin_chart/src/line.rs
+++ b/crates/nu_plugin_chart/src/line.rs
@@ -93,12 +93,12 @@ impl<'a> Line<'a> {
 
             let y_labels = vec![
                 Span::styled(
-                    format!("{}", self.y_range[0]),
+                    self.y_range[0].to_string(),
                     Style::default().add_modifier(Modifier::BOLD),
                 ),
-                Span::raw(format!("{}", (self.y_range[0] + self.y_range[1]) / 2.0)),
+                Span::raw(((self.y_range[0] + self.y_range[1]) / 2.0).to_string()),
                 Span::styled(
-                    format!("{}", self.y_range[1]),
+                    self.y_range[1].to_string(),
                     Style::default().add_modifier(Modifier::BOLD),
                 ),
             ];
diff --git a/crates/nu_plugin_from_bson/src/from_bson.rs b/crates/nu_plugin_from_bson/src/from_bson.rs
index cf146b9f6..e2388cddc 100644
--- a/crates/nu_plugin_from_bson/src/from_bson.rs
+++ b/crates/nu_plugin_from_bson/src/from_bson.rs
@@ -42,7 +42,7 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Result<Value
         Bson::Array(a) => UntaggedValue::Table(bson_array(a, tag.clone())?).into_value(&tag),
         Bson::Document(doc) => {
             let mut collected = TaggedDictBuilder::new(tag.clone());
-            for (k, v) in doc.iter() {
+            for (k, v) in doc {
                 collected.insert_value(k.clone(), convert_bson_value_to_nu_value(v, &tag)?);
             }
 
@@ -67,7 +67,7 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Result<Value
         Bson::Decimal128(n) => {
             // TODO: this really isn't great, and we should update this to do a higher
             // fidelity translation
-            let decimal = BigDecimal::from_str(&format!("{}", n)).map_err(|_| {
+            let decimal = BigDecimal::from_str(&n.to_string()).map_err(|_| {
                 ShellError::range_error(
                     ExpectedRange::BigDecimal,
                     &n.spanned(span),
diff --git a/crates/nu_plugin_from_mp4/src/from_mp4.rs b/crates/nu_plugin_from_mp4/src/from_mp4.rs
index 747e1a167..48404a402 100644
--- a/crates/nu_plugin_from_mp4/src/from_mp4.rs
+++ b/crates/nu_plugin_from_mp4/src/from_mp4.rs
@@ -63,7 +63,7 @@ pub fn convert_mp4_file_to_nu_value(path: &Path, tag: Tag) -> Result<Value, mp4:
         curr_track_dict.insert_untagged(
             "sample freq index",
             match track.sample_freq_index() {
-                Ok(sfi) => UntaggedValue::string(format!("{}", sfi.freq())), // this is a string for formatting reasons
+                Ok(sfi) => UntaggedValue::string(sfi.freq().to_string()), // this is a string for formatting reasons
                 Err(_) => UntaggedValue::from("Unknown"),
             },
         );
diff --git a/crates/nu_plugin_inc/src/inc.rs b/crates/nu_plugin_inc/src/inc.rs
index 78c58f1a2..0b6f322fa 100644
--- a/crates/nu_plugin_inc/src/inc.rs
+++ b/crates/nu_plugin_inc/src/inc.rs
@@ -45,7 +45,7 @@ impl Inc {
                 UntaggedValue::string(ver.to_string())
             }
             Some(Action::Default) | None => match input.parse::<u64>() {
-                Ok(v) => UntaggedValue::string(format!("{}", v + 1)),
+                Ok(v) => UntaggedValue::string((v + 1).to_string()),
                 Err(_) => UntaggedValue::string(input),
             },
         }
diff --git a/crates/nu_plugin_inc/src/nu/tests.rs b/crates/nu_plugin_inc/src/nu/tests.rs
index afc6b5454..e97a8941d 100644
--- a/crates/nu_plugin_inc/src/nu/tests.rs
+++ b/crates/nu_plugin_inc/src/nu/tests.rs
@@ -17,7 +17,7 @@ mod integration {
                     .create(),
             )
             .setup(|plugin, returned_values| {
-                let actual = format!("{}", returned_values.unwrap_err());
+                let actual = returned_values.unwrap_err().to_string();
 
                 assert!(actual.contains("can only apply one"));
                 assert_eq!(plugin.error, Some("can only apply one".to_string()));
diff --git a/crates/nu_plugin_query_json/src/query_json.rs b/crates/nu_plugin_query_json/src/query_json.rs
index 74b7ffc2b..9b58b8fc1 100644
--- a/crates/nu_plugin_query_json/src/query_json.rs
+++ b/crates/nu_plugin_query_json/src/query_json.rs
@@ -35,7 +35,7 @@ fn execute_json_query(
     let tag = tag.into();
 
     // Validate the json before trying to query it
-    let is_valid_json = gjson::valid(input_string.as_str());
+    let is_valid_json = gjson::valid(&input_string);
     if !is_valid_json {
         return Err(ShellError::labeled_error(
             "invalid json",
@@ -45,9 +45,9 @@ fn execute_json_query(
     }
 
     let mut ret: Vec<Value> = vec![];
-    let val: gjValue = gjson::get(input_string.as_str(), &query_string);
+    let val: gjValue = gjson::get(&input_string, &query_string);
 
-    if query_contains_modifiers(query_string.as_str()) {
+    if query_contains_modifiers(&query_string) {
         let json_str = val.json();
         let json_val = Value::from(json_str);
         ret.push(json_val);
@@ -59,7 +59,7 @@ fn execute_json_query(
             UntaggedValue::Row(_) => ret.push(gjv),
             UntaggedValue::Table(t) => {
                 // Unravel the table so it's not a table inside of a table in the output
-                for v in t.iter() {
+                for v in &t {
                     let c = v.clone();
                     ret.push(c)
                 }
diff --git a/crates/nu_plugin_selector/src/selector.rs b/crates/nu_plugin_selector/src/selector.rs
index 4ce863c39..f9bf8f188 100644
--- a/crates/nu_plugin_selector/src/selector.rs
+++ b/crates/nu_plugin_selector/src/selector.rs
@@ -28,16 +28,10 @@ impl Default for Selector {
 
 pub fn begin_selector_query(input_html: String, selector: &Selector) -> Vec<Value> {
     match selector.attribute.is_empty() {
-        true => execute_selector_query(
-            input_html.as_str(),
-            selector.query.as_str(),
-            selector.as_html,
-        ),
-        false => execute_selector_query_with_attribute(
-            input_html.as_str(),
-            selector.query.as_str(),
-            selector.attribute.as_str(),
-        ),
+        true => execute_selector_query(&input_html, &selector.query, selector.as_html),
+        false => {
+            execute_selector_query_with_attribute(&input_html, &selector.query, &selector.attribute)
+        }
     }
 }
 
diff --git a/crates/nu_plugin_start/src/start.rs b/crates/nu_plugin_start/src/start.rs
index 4914035b7..068c2abb3 100644
--- a/crates/nu_plugin_start/src/start.rs
+++ b/crates/nu_plugin_start/src/start.rs
@@ -51,7 +51,7 @@ impl Start {
                             .push(path.to_string_lossy().to_string().tagged(value.tag.clone())),
                         Err(glob_error) => {
                             return Err(ShellError::labeled_error(
-                                format!("{}", glob_error),
+                                glob_error.to_string(),
                                 "glob error",
                                 value.tag.clone(),
                             ));
@@ -61,7 +61,7 @@ impl Start {
             }
             Err(pattern_error) => {
                 return Err(ShellError::labeled_error(
-                    format!("{}", pattern_error),
+                    pattern_error.to_string(),
                     "invalid pattern",
                     value.tag.clone(),
                 ))
@@ -76,7 +76,7 @@ impl Start {
             Some(values) => {
                 let mut result = vec![];
 
-                for value in values.iter() {
+                for value in values {
                     let val_str = value.as_string();
                     match val_str {
                         Ok(s) => {
@@ -208,7 +208,7 @@ impl Start {
         if let Some(app_name) = &self.application {
             exec_cmd(app_name, &args, self.tag.clone())
         } else {
-            for cmd in &["xdg-open", "gnome-open", "kde-open", "wslview"] {
+            for cmd in ["xdg-open", "gnome-open", "kde-open", "wslview"] {
                 if exec_cmd(cmd, &args, self.tag.clone()).is_err() {
                     continue;
                 } else {
diff --git a/crates/nu_plugin_to_bson/src/to_bson.rs b/crates/nu_plugin_to_bson/src/to_bson.rs
index 228aa10b8..5d592cfa0 100644
--- a/crates/nu_plugin_to_bson/src/to_bson.rs
+++ b/crates/nu_plugin_to_bson/src/to_bson.rs
@@ -197,7 +197,7 @@ fn get_binary_subtype(tagged_value: &Value) -> Result<BinarySubtype, ShellError>
 // correspond to a special bson type (things like regex or javascript code).
 fn generic_object_value_to_bson(o: &Dictionary) -> Result<Bson, ShellError> {
     let mut doc = Document::new();
-    for (k, v) in o.entries.iter() {
+    for (k, v) in &o.entries {
         doc.insert(k.clone(), value_to_bson_value(v)?);
     }
     Ok(Bson::Document(doc))
@@ -218,7 +218,7 @@ fn bson_value_to_bytes(bson: Bson, tag: Tag) -> Result<Vec<u8>, ShellError> {
     let mut out = Vec::new();
     match bson {
         Bson::Array(a) => {
-            for v in a.into_iter() {
+            for v in a {
                 match v {
                     Bson::Document(d) => shell_encode_document(&mut out, d, tag.clone())?,
                     _ => {
diff --git a/crates/nu_plugin_to_sqlite/src/to_sqlite.rs b/crates/nu_plugin_to_sqlite/src/to_sqlite.rs
index 8d5055a2f..69466338c 100644
--- a/crates/nu_plugin_to_sqlite/src/to_sqlite.rs
+++ b/crates/nu_plugin_to_sqlite/src/to_sqlite.rs
@@ -41,11 +41,11 @@ fn nu_value_to_sqlite_string(v: Value) -> String {
     match &v.value {
         UntaggedValue::Primitive(p) => match p {
             Primitive::Nothing => "NULL".into(),
-            Primitive::BigInt(i) => format!("{}", i),
-            Primitive::Int(i) => format!("{}", i),
-            Primitive::Duration(i) => format!("{}", i),
-            Primitive::Decimal(f) => format!("{}", f),
-            Primitive::Filesize(u) => format!("{}", u),
+            Primitive::BigInt(i) => i.to_string(),
+            Primitive::Int(i) => i.to_string(),
+            Primitive::Duration(i) => i.to_string(),
+            Primitive::Decimal(f) => f.to_string(),
+            Primitive::Filesize(u) => u.to_string(),
             Primitive::GlobPattern(s) => format!("'{}'", s.replace("'", "''")),
             Primitive::String(s) => format!("'{}'", s.replace("'", "''")),
             Primitive::Boolean(true) => "1".into(),
@@ -130,7 +130,7 @@ fn sqlite_input_stream_to_bytes(values: Vec<Value>) -> Result<Value, std::io::Er
         Err(e) => return Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
     };
     let tag = values[0].tag.clone();
-    for value in values.into_iter() {
+    for value in values {
         match &value.value {
             UntaggedValue::Row(d) => {
                 let (create, insert) = generate_statements(d.to_owned())?;
diff --git a/crates/nu_plugin_tree/src/nu/mod.rs b/crates/nu_plugin_tree/src/nu/mod.rs
index 632b0a627..fcec4e9bd 100644
--- a/crates/nu_plugin_tree/src/nu/mod.rs
+++ b/crates/nu_plugin_tree/src/nu/mod.rs
@@ -11,11 +11,9 @@ impl Plugin for TreeViewer {
     }
 
     fn sink(&mut self, _call_info: CallInfo, input: Vec<Value>) {
-        if !input.is_empty() {
-            for i in input.iter() {
-                let view = TreeView::from_value(i);
-                let _ = view.render_view();
-            }
+        for i in &input {
+            let view = TreeView::from_value(i);
+            let _ = view.render_view();
         }
     }
 }
diff --git a/crates/nu_plugin_tree/src/tree.rs b/crates/nu_plugin_tree/src/tree.rs
index b1f383ef7..ccb65183b 100644
--- a/crates/nu_plugin_tree/src/tree.rs
+++ b/crates/nu_plugin_tree/src/tree.rs
@@ -20,14 +20,14 @@ impl TreeView {
                 let _ = builder.add_empty_child(format_primitive(p, None));
             }
             UntaggedValue::Row(o) => {
-                for (k, v) in o.entries.iter() {
+                for (k, v) in &o.entries {
                     builder = builder.begin_child(k.clone());
                     Self::from_value_helper(v, builder);
                     builder = builder.end_child();
                 }
             }
             UntaggedValue::Table(l) => {
-                for elem in l.iter() {
+                for elem in l {
                     Self::from_value_helper(elem, builder);
                 }
             }