refactor: introduce is_external_failed to PipelineData, and simplify try logic (#7476)

# Description

Just spot that there are some duplicate code about checking external
runs to failed, is pr is trying to refactor it and reduce lines of code

# User-Facing Changes

NaN

# Tests + Formatting

Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# After Submitting

If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.

crates/nu-command/src/core_commands/try_.rs

@@ -1,9 +1,7 @@
 use nu_engine::{eval_block, CallExt};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Block, Closure, Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, ListStream, PipelineData, Signature, SyntaxShape, Type, Value,
-};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct Try;
@@ -80,30 +78,9 @@ impl Command for Try {
                 }
             }
             // external command may fail to run
-            Ok(PipelineData::ExternalStream {
-                stdout: None,
-                stderr,
-                mut exit_code,
-                span,
-                metadata,
-                trim_end_newline,
-            }) => {
-                let exit_code = exit_code.take();
-                let mut failed_to_run = false;
-                let mut exit_code_stream = None;
-                if let Some(stream) = exit_code {
-                    let ctrlc = stream.ctrlc.clone();
-                    let exit_code: Vec<Value> = stream.into_iter().collect();
-                    if let Some(Value::Int { val: code, .. }) = exit_code.last() {
-                        // if exit_code is not 0, it indicates error occured, return back Err.
-                        if *code != 0 {
-                            failed_to_run = true;
-                        }
-                    }
-                    exit_code_stream = Some(ListStream::from_stream(exit_code.into_iter(), ctrlc));
-                }
-
-                if failed_to_run {
+            Ok(pipeline) => {
+                let (pipeline, external_failed) = pipeline.is_external_failed();
+                if external_failed {
                     if let Some(catch_block) = catch_block {
                         let catch_block = engine_state.get_block(catch_block.block_id);
 
@@ -126,17 +103,9 @@ impl Command for Try {
                         Ok(PipelineData::empty())
                     }
                 } else {
-                    Ok(PipelineData::ExternalStream {
-                        stdout: None,
-                        stderr,
-                        exit_code: exit_code_stream,
-                        span,
-                        metadata,
-                        trim_end_newline,
-                    })
+                    Ok(pipeline)
                 }
             }
-            Ok(output) => Ok(output),
         }
     }