Reduce again the number of match calls (#7815)

- Reduce the number of match calls (see commit messages)
- A few miscellaneous improvements

crates/nu-cli/src/config_files.rs

@@ -56,12 +56,11 @@ pub fn add_plugin_file(
         let working_set = StateWorkingSet::new(engine_state);
         let cwd = working_set.get_cwd();
 
-        match canonicalize_with(&plugin_file.item, cwd) {
-            Ok(path) => engine_state.plugin_signatures = Some(path),
-            Err(_) => {
-                let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
-                report_error(&working_set, &e);
-            }
+        if let Ok(path) = canonicalize_with(&plugin_file.item, cwd) {
+            engine_state.plugin_signatures = Some(path)
+        } else {
+            let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
+            report_error(&working_set, &e);
         }
     } else if let Some(mut plugin_path) = nu_path::config_dir() {
         // Path to store plugins signatures

crates/nu-cli/src/menus/menu_completions.rs

@@ -81,13 +81,10 @@ fn convert_to_suggestions(
 ) -> Vec<Suggestion> {
     match value {
         Value::Record { .. } => {
-            let text = match value
+            let text = value
                 .get_data_by_key("value")
                 .and_then(|val| val.as_string().ok())
-            {
-                Some(val) => val,
-                None => "No value key".to_string(),
-            };
+                .unwrap_or_else(|| "No value key".to_string());
 
             let description = value
                 .get_data_by_key("description")

crates/nu-cli/src/prompt_update.rs

@@ -77,20 +77,17 @@ fn get_prompt_string(
         .and_then(|pipeline_data| {
             let output = pipeline_data.collect_string("", config).ok();
 
-            match output {
-                Some(mut x) => {
-                    // Just remove the very last newline.
-                    if x.ends_with('\n') {
-                        x.pop();
-                    }
-
-                    if x.ends_with('\r') {
-                        x.pop();
-                    }
-                    Some(x)
+            output.map(|mut x| {
+                // Just remove the very last newline.
+                if x.ends_with('\n') {
+                    x.pop();
                 }
-                None => None,
-            }
+
+                if x.ends_with('\r') {
+                    x.pop();
+                }
+                x
+            })
         })
 }
 
@@ -107,12 +104,13 @@ pub(crate) fn update_prompt<'prompt>(
     // Now that we have the prompt string lets ansify it.
     // <133 A><prompt><133 B><command><133 C><command output>
     let left_prompt_string = if config.shell_integration {
-        match left_prompt_string {
-            Some(prompt_string) => Some(format!(
+        if let Some(prompt_string) = left_prompt_string {
+            Some(format!(
                 "{}{}{}",
                 PRE_PROMPT_MARKER, prompt_string, POST_PROMPT_MARKER
-            )),
-            None => left_prompt_string,
+            ))
+        } else {
+            left_prompt_string
         }
     } else {
         left_prompt_string

crates/nu-cli/src/reedline_config.rs

@@ -651,14 +651,15 @@ fn add_parsed_keybinding(
             let pos1 = char_iter.next();
             let pos2 = char_iter.next();
 
-            let char = match (pos1, pos2) {
-                (Some(char), None) => Ok(char),
-                _ => Err(ShellError::UnsupportedConfigValue(
+            let char = if let (Some(char), None) = (pos1, pos2) {
+                char
+            } else {
+                return Err(ShellError::UnsupportedConfigValue(
                     "char_<CHAR: unicode codepoint>".to_string(),
                     c.to_string(),
                     keybinding.keycode.span()?,
-                )),
-            }?;
+                ));
+            };
 
             KeyCode::Char(char)
         }

crates/nu-cli/src/repl.rs

@@ -1002,18 +1002,15 @@ fn run_hook_block(
 }
 
 fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
-    match io::stdout().write_all(seq.as_bytes()) {
-        Ok(it) => it,
-        Err(err) => {
-            return Err(ShellError::GenericError(
-                "Error writing ansi sequence".into(),
-                err.to_string(),
-                Some(Span::unknown()),
-                None,
-                Vec::new(),
-            ));
-        }
-    };
+    io::stdout().write_all(seq.as_bytes()).map_err(|e| {
+        ShellError::GenericError(
+            "Error writing ansi sequence".into(),
+            e.to_string(),
+            Some(Span::unknown()),
+            None,
+            Vec::new(),
+        )
+    })?;
     io::stdout().flush().map_err(|e| {
         ShellError::GenericError(
             "Error flushing stdio".into(),

crates/nu-cli/src/util.rs

@@ -315,27 +315,19 @@ pub fn report_error_new(
 }
 
 pub fn get_init_cwd() -> PathBuf {
-    match std::env::current_dir() {
-        Ok(cwd) => cwd,
-        Err(_) => match std::env::var("PWD") {
-            Ok(cwd) => PathBuf::from(cwd),
-            Err(_) => match nu_path::home_dir() {
-                Some(cwd) => cwd,
-                None => PathBuf::new(),
-            },
-        },
-    }
+    std::env::current_dir().unwrap_or_else(|_| {
+        std::env::var("PWD")
+            .map(Into::into)
+            .unwrap_or_else(|_| nu_path::home_dir().unwrap_or_default())
+    })
 }
 
 pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
-    match nu_engine::env::current_dir(engine_state, stack) {
-        Ok(p) => p,
-        Err(e) => {
-            let working_set = StateWorkingSet::new(engine_state);
-            report_error(&working_set, &e);
-            get_init_cwd()
-        }
-    }
+    nu_engine::env::current_dir(engine_state, stack).unwrap_or_else(|e| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        get_init_cwd()
+    })
 }
 
 #[cfg(test)]