Move Value to helpers, separate span call (#10121)

# Description

As part of the refactor to split spans off of Value, this moves to using
helper functions to create values, and using `.span()` instead of
matching span out of Value directly.

Hoping to get a few more helping hands to finish this, as there are a
lot of commands to update :)

# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->

# 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` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use std testing; testing run-tests --path
crates/nu-std"` to run the tests for the standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->

# 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.
-->

---------

Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com>
Co-authored-by: WindSoilder <windsoilder@outlook.com>

crates/nu-command/src/conversions/into/duration.rs

@@ -62,71 +62,50 @@ impl Command for SubCommand {
             Example {
                 description: "Convert duration string to duration value",
                 example: "'7min' | into duration",
-                result: Some(Value::Duration {
-                    val: 7 * 60 * NS_PER_SEC,
-                    span,
-                }),
+                result: Some(Value::duration(7 * 60 * NS_PER_SEC, span)),
             },
             Example {
                 description: "Convert compound duration string to duration value",
                 example: "'1day 2hr 3min 4sec' | into duration",
-                result: Some(Value::Duration {
-                    val: (((((/* 1 * */24) + 2) * 60) + 3) * 60 + 4) * NS_PER_SEC,
+                result: Some(Value::duration(
+                    (((((/* 1 * */24) + 2) * 60) + 3) * 60 + 4) * NS_PER_SEC,
                     span,
-                }),
+                )),
             },
             Example {
                 description: "Convert table of duration strings to table of duration values",
                 example:
                     "[[value]; ['1sec'] ['2min'] ['3hr'] ['4day'] ['5wk']] | into duration value",
-                result: Some(Value::List {
-                    vals: vec![
+                result: Some(Value::list(
+                    vec![
                         Value::test_record(Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::Duration {
-                                val: NS_PER_SEC,
-                                span,
-                            }],
+                            vals: vec![Value::duration(NS_PER_SEC, span)],
                         }),
                         Value::test_record(Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::Duration {
-                                val: 2 * 60 * NS_PER_SEC,
-                                span,
-                            }],
+                            vals: vec![Value::duration(2 * 60 * NS_PER_SEC, span)],
                         }),
                         Value::test_record(Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::Duration {
-                                val: 3 * 60 * 60 * NS_PER_SEC,
-                                span,
-                            }],
+                            vals: vec![Value::duration(3 * 60 * 60 * NS_PER_SEC, span)],
                         }),
                         Value::test_record(Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::Duration {
-                                val: 4 * 24 * 60 * 60 * NS_PER_SEC,
-                                span,
-                            }],
+                            vals: vec![Value::duration(4 * 24 * 60 * 60 * NS_PER_SEC, span)],
                         }),
                         Value::test_record(Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::Duration {
-                                val: 5 * 7 * 24 * 60 * 60 * NS_PER_SEC,
-                                span,
-                            }],
+                            vals: vec![Value::duration(5 * 7 * 24 * 60 * 60 * NS_PER_SEC, span)],
                         }),
                     ],
                     span,
-                }),
+                )),
             },
             Example {
                 description: "Convert duration to duration",
                 example: "420sec | into duration",
-                result: Some(Value::Duration {
-                    val: 7 * 60 * NS_PER_SEC,
-                    span,
-                }),
+                result: Some(Value::duration(7 * 60 * NS_PER_SEC, span)),
             },
         ]
     }
@@ -154,10 +133,7 @@ fn into_duration(
                     let r =
                         ret.update_cell_path(&path.members, Box::new(move |old| action(old, span)));
                     if let Err(error) = r {
-                        return Value::Error {
-                            error: Box::new(error),
-                            span,
-                        };
+                        return Value::error(error, span);
                     }
                 }
 
@@ -227,29 +203,24 @@ fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
 }
 
 fn action(input: &Value, span: Span) -> Value {
+    let value_span = input.span();
     match input {
         Value::Duration { .. } => input.clone(),
-        Value::String {
-            val,
-            span: value_span,
-        } => match compound_to_duration(val, *value_span) {
-            Ok(val) => Value::Duration { val, span },
-            Err(error) => Value::Error {
-                error: Box::new(error),
-                span,
-            },
+        Value::String { val, .. } => match compound_to_duration(val, value_span) {
+            Ok(val) => Value::duration(val, span),
+            Err(error) => Value::error(error, span),
         },
         // Propagate errors by explicitly matching them before the final case.
         Value::Error { .. } => input.clone(),
-        other => Value::Error {
-            error: Box::new(ShellError::OnlySupportsThisInputType {
+        other => Value::error(
+            ShellError::OnlySupportsThisInputType {
                 exp_input_type: "string or duration".into(),
                 wrong_type: other.get_type().to_string(),
                 dst_span: span,
                 src_span: other.span(),
-            }),
+            },
             span,
-        },
+        ),
     }
 }