Reduced LOC by replacing several instances of Value::Int {}, Value::Float{}, Value::Bool {}, and Value::String {} with Value::int(), Value::float(), Value::boolean() and Value::string() (#7412)

# Description

While perusing Value.rs, I noticed the `Value::int()`, `Value::float()`,
`Value::boolean()` and `Value::string()` constructors, which seem
designed to make it easier to construct various Values, but which aren't
used often at all in the codebase. So, using a few find-replaces
regexes, I increased their usage. This reduces overall LOC because
structures like this:
```
Value::Int {
  val: a,
  span: head
}
```
are changed into
```
Value::int(a, head)
```
and are respected as such by the project's formatter.
There are little readability concerns because the second argument to all
of these is `span`, and it's almost always extremely obvious which is
the span at every callsite.

# User-Facing Changes

None.

# 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/conversions/into/decimal.rs

@@ -86,7 +86,7 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
             let other = s.trim();
 
             match other.parse::<f64>() {
-                Ok(x) => Value::Float { val: x, span: head },
+                Ok(x) => Value::float(x, head),
                 Err(reason) => Value::Error {
                     error: ShellError::CantConvert(
                         "float".to_string(),
@@ -97,10 +97,7 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
                 },
             }
         }
-        Value::Int { val: v, span } => Value::Float {
-            val: *v as f64,
-            span: *span,
-        },
+        Value::Int { val: v, span } => Value::float(*v as f64, *span),
         Value::Bool { val: b, span } => Value::Float {
             val: match b {
                 true => 1.0,

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

@@ -113,10 +113,7 @@ impl Command for SubCommand {
             Example {
                 description: "Convert file size to integer",
                 example: "4KB | into int",
-                result: Some(Value::Int {
-                    val: 4000,
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::int(4000, Span::test_data())),
             },
             Example {
                 description: "Convert bool to integer",
@@ -233,20 +230,14 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
                 }
                 val.resize(8, 0);
 
-                Value::Int {
-                    val: LittleEndian::read_i64(&val),
-                    span: *span,
-                }
+                Value::int(LittleEndian::read_i64(&val), *span)
             } else {
                 while val.len() < 8 {
                     val.insert(0, 0);
                 }
                 val.resize(8, 0);
 
-                Value::Int {
-                    val: BigEndian::read_i64(&val),
-                    span: *span,
-                }
+                Value::int(BigEndian::read_i64(&val), *span)
             }
         }
         _ => Value::Error {
@@ -269,13 +260,13 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             // octal
             {
                 match int_from_string(val, head) {
-                    Ok(x) => return Value::Int { val: x, span: head },
+                    Ok(x) => return Value::int(x, head),
                     Err(e) => return Value::Error { error: e },
                 }
             } else if val.starts_with("00") {
                 // It's a padded string
                 match i64::from_str_radix(val, radix) {
-                    Ok(n) => return Value::Int { val: n, span: head },
+                    Ok(n) => return Value::int(n, head),
                     Err(e) => {
                         return Value::Error {
                             error: ShellError::CantConvert(
@@ -300,7 +291,7 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
         }
     };
     match i64::from_str_radix(i.trim(), radix) {
-        Ok(n) => Value::Int { val: n, span: head },
+        Ok(n) => Value::int(n, head),
         Err(_reason) => Value::Error {
             error: ShellError::CantConvert("string".to_string(), "int".to_string(), head, None),
         },

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

@@ -79,34 +79,22 @@ impl Command for SubCommand {
             Example {
                 description: "convert integer to string and append three decimal places",
                 example: "5 | into string -d 3",
-                result: Some(Value::String {
-                    val: "5.000".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("5.000", Span::test_data())),
             },
             Example {
                 description: "convert decimal to string and round to nearest integer",
                 example: "1.7 | into string -d 0",
-                result: Some(Value::String {
-                    val: "2".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("2", Span::test_data())),
             },
             Example {
                 description: "convert decimal to string",
                 example: "1.7 | into string -d 1",
-                result: Some(Value::String {
-                    val: "1.7".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("1.7", Span::test_data())),
             },
             Example {
                 description: "convert decimal to string and limit to 2 decimals",
                 example: "1.734 | into string -d 2",
-                result: Some(Value::String {
-                    val: "1.73".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("1.73", Span::test_data())),
             },
             Example {
                 description: "try to convert decimal to string and provide negative decimal points",
@@ -123,26 +111,17 @@ impl Command for SubCommand {
             Example {
                 description: "convert decimal to string",
                 example: "4.3 | into string",
-                result: Some(Value::String {
-                    val: "4.3".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("4.3", Span::test_data())),
             },
             Example {
                 description: "convert string to string",
                 example: "'1234' | into string",
-                result: Some(Value::String {
-                    val: "1234".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("1234", Span::test_data())),
             },
             Example {
                 description: "convert boolean to string",
                 example: "true | into string",
-                result: Some(Value::String {
-                    val: "true".to_string(),
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::string("true", Span::test_data())),
             },
             // TODO: This should work but does not; see https://github.com/nushell/nushell/issues/7032
             // Example {