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-cmd-dataframe/src/dataframe/eager/columns.rs

@@ -27,10 +27,10 @@ impl Command for ColumnsDF {
         vec![Example {
             description: "Dataframe columns",
             example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr columns",
-            result: Some(Value::List {
-                vals: vec![Value::test_string("a"), Value::test_string("b")],
-                span: Span::test_data(),
-            }),
+            result: Some(Value::list(
+                vec![Value::test_string("a"), Value::test_string("b")],
+                Span::test_data(),
+            )),
         }]
     }
 
@@ -60,10 +60,7 @@ fn command(
         .map(|v| Value::string(*v, call.head))
         .collect();
 
-    let names = Value::List {
-        vals: names,
-        span: call.head,
-    };
+    let names = Value::list(names, call.head);
 
     Ok(PipelineData::Value(names, None))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/dtypes.rs

@@ -79,10 +79,7 @@ fn command(
                 .dtype();
 
             let dtype_str = dtype.to_string();
-            dtypes.push(Value::String {
-                val: dtype_str,
-                span: call.head,
-            });
+            dtypes.push(Value::string(dtype_str, call.head));
 
             Value::string(*v, call.head)
         })

crates/nu-cmd-dataframe/src/dataframe/eager/list.rs

@@ -66,10 +66,7 @@ impl Command for ListDF {
             })
             .collect::<Vec<Value>>();
 
-        let list = Value::List {
-            vals,
-            span: call.head,
-        };
+        let list = Value::list(vals, call.head);
 
         Ok(list.into_pipeline_data())
     }

crates/nu-cmd-dataframe/src/dataframe/eager/query_df.rs

@@ -88,10 +88,7 @@ fn command(
     let lazy = NuLazyFrame::new(false, df_sql);
 
     let eager = lazy.collect(call.head)?;
-    let value = Value::CustomValue {
-        val: Box::new(eager),
-        span: call.head,
-    };
+    let value = Value::custom_value(Box::new(eager), call.head);
 
     Ok(PipelineData::Value(value, None))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/summary.rs

@@ -120,30 +120,30 @@ fn command(
     let quantiles = quantiles.map(|values| {
         values
             .iter()
-            .map(|value| match value {
-                Value::Float { val, span } => {
-                    if (&0.0..=&1.0).contains(&val) {
-                        Ok(*val)
-                    } else {
-                        Err(ShellError::GenericError(
-                            "Incorrect value for quantile".to_string(),
-                            "value should be between 0 and 1".to_string(),
-                            Some(*span),
-                            None,
-                            Vec::new(),
-                        ))
+            .map(|value| {
+                let span = value.span();
+                match value {
+                    Value::Float { val, .. } => {
+                        if (&0.0..=&1.0).contains(&val) {
+                            Ok(*val)
+                        } else {
+                            Err(ShellError::GenericError(
+                                "Incorrect value for quantile".to_string(),
+                                "value should be between 0 and 1".to_string(),
+                                Some(span),
+                                None,
+                                Vec::new(),
+                            ))
+                        }
                     }
-                }
-                Value::Error { error, .. } => Err(*error.clone()),
-                _ => {
-                    let span = value.span();
-                    Err(ShellError::GenericError(
+                    Value::Error { error, .. } => Err(*error.clone()),
+                    _ => Err(ShellError::GenericError(
                         "Incorrect value for quantile".to_string(),
                         "value should be a float".to_string(),
                         Some(span),
                         None,
                         Vec::new(),
-                    ))
+                    )),
                 }
             })
             .collect::<Result<Vec<f64>, ShellError>>()

crates/nu-cmd-dataframe/src/dataframe/eager/to_arrow.rs

@@ -78,16 +78,10 @@ fn command(
         )
     })?;
 
-    let file_value = Value::String {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_avro.rs

@@ -108,16 +108,10 @@ fn command(
             )
         })?;
 
-    let file_value = Value::String {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_csv.rs

@@ -124,16 +124,10 @@ fn command(
         )
     })?;
 
-    let file_value = Value::String {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_json_lines.rs

@@ -81,16 +81,10 @@ fn command(
             )
         })?;
 
-    let file_value = Value::String {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_nu.rs

@@ -57,18 +57,12 @@ impl Command for ToNu {
             Example {
                 description: "Shows head rows from dataframe",
                 example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr into-nu",
-                result: Some(Value::List {
-                    vals: vec![rec_1, rec_2],
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::list(vec![rec_1, rec_2], Span::test_data())),
             },
             Example {
                 description: "Shows tail rows from dataframe",
                 example: "[[a b]; [1 2] [5 6] [3 4]] | dfr into-df | dfr into-nu -t -n 1",
-                result: Some(Value::List {
-                    vals: vec![rec_3],
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::list(vec![rec_3], Span::test_data())),
             },
             Example {
                 description: "Convert a col expression into a nushell value",
@@ -119,10 +113,7 @@ fn dataframe_command(
         }
     };
 
-    let value = Value::List {
-        vals: values,
-        span: call.head,
-    };
+    let value = Value::list(values, call.head);
 
     Ok(PipelineData::Value(value, None))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_parquet.rs

@@ -78,16 +78,10 @@ fn command(
         )
     })?;
 
-    let file_value = Value::String {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/with_column.rs

@@ -132,10 +132,7 @@ fn command_eager(
 
     if NuExpression::can_downcast(&new_column) {
         let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
-        let value = Value::List {
-            vals,
-            span: call.head,
-        };
+        let value = Value::list(vals, call.head);
         let expressions = NuExpression::extract_exprs(value)?;
         let lazy = NuLazyFrame::new(true, df.lazy().with_columns(&expressions));
 
@@ -179,10 +176,7 @@ fn command_lazy(
     lazy: NuLazyFrame,
 ) -> Result<PipelineData, ShellError> {
     let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
-    let value = Value::List {
-        vals,
-        span: call.head,
-    };
+    let value = Value::list(vals, call.head);
     let expressions = NuExpression::extract_exprs(value)?;
 
     let lazy: NuLazyFrame = lazy.into_polars().with_columns(&expressions).into();

crates/nu-cmd-dataframe/src/dataframe/lazy/aggregate.rs

@@ -114,10 +114,7 @@ impl Command for LazyAggregate {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
-        let value = Value::List {
-            vals,
-            span: call.head,
-        };
+        let value = Value::list(vals, call.head);
         let expressions = NuExpression::extract_exprs(value)?;
 
         let group_by = NuLazyGroupBy::try_from_pipeline(input, call.head)?;

crates/nu-cmd-dataframe/src/dataframe/lazy/collect.rs

@@ -58,10 +58,7 @@ impl Command for LazyCollect {
     ) -> Result<PipelineData, ShellError> {
         let lazy = NuLazyFrame::try_from_pipeline(input, call.head)?;
         let eager = lazy.collect(call.head)?;
-        let value = Value::CustomValue {
-            val: Box::new(eager),
-            span: call.head,
-        };
+        let value = Value::custom_value(Box::new(eager), call.head);
 
         Ok(PipelineData::Value(value, None))
     }

crates/nu-cmd-dataframe/src/dataframe/lazy/fill_nan.rs

@@ -102,18 +102,21 @@ impl Command for LazyFillNA {
                     let column_name = column.name().to_string();
                     let values = column
                         .into_iter()
-                        .map(|value| match value {
-                            Value::Float { val, .. } => {
-                                if val.is_nan() {
-                                    fill.clone()
-                                } else {
-                                    value
+                        .map(|value| {
+                            let span = value.span();
+                            match value {
+                                Value::Float { val, .. } => {
+                                    if val.is_nan() {
+                                        fill.clone()
+                                    } else {
+                                        value
+                                    }
                                 }
+                                Value::List { vals, .. } => {
+                                    NuDataFrame::fill_list_nan(vals, span, fill.clone())
+                                }
+                                _ => value,
                             }
-                            Value::List { vals, span } => {
-                                NuDataFrame::fill_list_nan(vals, span, fill.clone())
-                            }
-                            _ => value,
                         })
                         .collect::<Vec<Value>>();
                     Column::new(column_name, values)

crates/nu-cmd-dataframe/src/dataframe/lazy/groupby.rs

@@ -113,10 +113,7 @@ impl Command for ToLazyGroupBy {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
-        let value = Value::List {
-            vals,
-            span: call.head,
-        };
+        let value = Value::list(vals, call.head);
         let expressions = NuExpression::extract_exprs(value)?;
 
         if expressions

crates/nu-cmd-dataframe/src/dataframe/lazy/select.rs

@@ -55,10 +55,7 @@ impl Command for LazySelect {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
-        let value = Value::List {
-            vals,
-            span: call.head,
-        };
+        let value = Value::list(vals, call.head);
         let expressions = NuExpression::extract_exprs(value)?;
 
         let lazy = NuLazyFrame::try_from_pipeline(input, call.head)?;

crates/nu-cmd-dataframe/src/dataframe/lazy/sort_by_expr.rs

@@ -105,10 +105,7 @@ impl Command for LazySortBy {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
-        let value = Value::List {
-            vals,
-            span: call.head,
-        };
+        let value = Value::list(vals, call.head);
         let expressions = NuExpression::extract_exprs(value)?;
         let nulls_last = call.has_flag("nulls-last");
         let maintain_order = call.has_flag("maintain-order");

crates/nu-cmd-dataframe/src/dataframe/lazy/to_lazy.rs

@@ -41,10 +41,7 @@ impl Command for ToLazyFrame {
     ) -> Result<PipelineData, ShellError> {
         let df = NuDataFrame::try_from_iter(input.into_iter())?;
         let lazy = NuLazyFrame::from_dataframe(df);
-        let value = Value::CustomValue {
-            val: Box::new(lazy),
-            span: call.head,
-        };
+        let value = Value::custom_value(Box::new(lazy), call.head);
 
         Ok(PipelineData::Value(value, None))
     }

crates/nu-cmd-dataframe/src/dataframe/series/date/as_datetime.rs

@@ -56,22 +56,22 @@ impl Command for AsDateTime {
                     NuDataFrame::try_from_columns(vec![Column::new(
                         "datetime".to_string(),
                         vec![
-                            Value::Date {
-                                val: DateTime::parse_from_str(
+                            Value::date(
+                                DateTime::parse_from_str(
                                     "2021-12-30 00:00:00 +0000",
                                     "%Y-%m-%d %H:%M:%S %z",
                                 )
                                 .expect("date calculation should not fail in test"),
-                                span: Span::test_data(),
-                            },
-                            Value::Date {
-                                val: DateTime::parse_from_str(
+                                Span::test_data(),
+                            ),
+                            Value::date(
+                                DateTime::parse_from_str(
                                     "2021-12-31 00:00:00 +0000",
                                     "%Y-%m-%d %H:%M:%S %z",
                                 )
                                 .expect("date calculation should not fail in test"),
-                                span: Span::test_data(),
-                            },
+                                Span::test_data(),
+                            ),
                         ],
                     )])
                     .expect("simple df for test should not fail")
@@ -85,22 +85,22 @@ impl Command for AsDateTime {
                     NuDataFrame::try_from_columns(vec![Column::new(
                         "datetime".to_string(),
                         vec![
-                            Value::Date {
-                                val: DateTime::parse_from_str(
+                            Value::date(
+                                DateTime::parse_from_str(
                                     "2021-12-30 00:00:00.123456789 +0000",
                                     "%Y-%m-%d %H:%M:%S.%9f %z",
                                 )
                                 .expect("date calculation should not fail in test"),
-                                span: Span::test_data(),
-                            },
-                            Value::Date {
-                                val: DateTime::parse_from_str(
+                                Span::test_data(),
+                            ),
+                            Value::date(
+                                DateTime::parse_from_str(
                                     "2021-12-31 00:00:00.123456789 +0000",
                                     "%Y-%m-%d %H:%M:%S.%9f %z",
                                 )
                                 .expect("date calculation should not fail in test"),
-                                span: Span::test_data(),
-                            },
+                                Span::test_data(),
+                            ),
                         ],
                     )])
                     .expect("simple df for test should not fail")

crates/nu-cmd-dataframe/src/dataframe/series/indexes/set_with_idx.rs

@@ -123,8 +123,9 @@ fn command(
     let df = NuDataFrame::try_from_pipeline(input, call.head)?;
     let series = df.as_series(call.head)?;
 
+    let span = value.span();
     let res = match value {
-        Value::Int { val, span } => {
+        Value::Int { val, .. } => {
             let chunked = series.i64().map_err(|e| {
                 ShellError::GenericError(
                     "Error casting to i64".into(),
@@ -147,7 +148,7 @@ fn command(
 
             NuDataFrame::try_from_series(vec![res.into_series()], call.head)
         }
-        Value::Float { val, span } => {
+        Value::Float { val, .. } => {
             let chunked = series.f64().map_err(|e| {
                 ShellError::GenericError(
                     "Error casting to f64".into(),
@@ -170,7 +171,7 @@ fn command(
 
             NuDataFrame::try_from_series(vec![res.into_series()], call.head)
         }
-        Value::String { val, span } => {
+        Value::String { val, .. } => {
             let chunked = series.utf8().map_err(|e| {
                 ShellError::GenericError(
                     "Error casting to string".into(),
@@ -204,7 +205,7 @@ fn command(
                 "this value cannot be set in a series of type '{}'",
                 series.dtype()
             ),
-            Some(value.span()),
+            Some(span),
             None,
             Vec::new(),
         )),

crates/nu-cmd-dataframe/src/dataframe/series/masks/set.rs

@@ -105,9 +105,9 @@ fn command(
 
     let df = NuDataFrame::try_from_pipeline(input, call.head)?;
     let series = df.as_series(call.head)?;
-
+    let span = value.span();
     let res = match value {
-        Value::Int { val, span } => {
+        Value::Int { val, .. } => {
             let chunked = series.i64().map_err(|e| {
                 ShellError::GenericError(
                     "Error casting to i64".into(),
@@ -130,7 +130,7 @@ fn command(
 
             NuDataFrame::try_from_series(vec![res.into_series()], call.head)
         }
-        Value::Float { val, span } => {
+        Value::Float { val, .. } => {
             let chunked = series.f64().map_err(|e| {
                 ShellError::GenericError(
                     "Error casting to f64".into(),
@@ -153,7 +153,7 @@ fn command(
 
             NuDataFrame::try_from_series(vec![res.into_series()], call.head)
         }
-        Value::String { val, span } => {
+        Value::String { val, .. } => {
             let chunked = series.utf8().map_err(|e| {
                 ShellError::GenericError(
                     "Error casting to string".into(),
@@ -185,7 +185,7 @@ fn command(
                 "this value cannot be set in a series of type '{}'",
                 series.dtype()
             ),
-            Some(value.span()),
+            Some(span),
             None,
             Vec::new(),
         )),

crates/nu-cmd-dataframe/src/dataframe/values/nu_dataframe/between_values.rs

@@ -267,29 +267,37 @@ pub(super) fn compute_series_single_value(
                 rhs_span: right.span(),
             }),
         },
-        Operator::Math(Math::Divide) => match &right {
-            Value::Int { val, span } => {
-                if *val == 0 {
-                    Err(ShellError::DivisionByZero { span: *span })
-                } else {
-                    compute_series_i64(&lhs, *val, <ChunkedArray<Int64Type>>::div, lhs_span)
+        Operator::Math(Math::Divide) => {
+            let span = right.span();
+            match &right {
+                Value::Int { val, .. } => {
+                    if *val == 0 {
+                        Err(ShellError::DivisionByZero { span })
+                    } else {
+                        compute_series_i64(&lhs, *val, <ChunkedArray<Int64Type>>::div, lhs_span)
+                    }
                 }
-            }
-            Value::Float { val, span } => {
-                if val.is_zero() {
-                    Err(ShellError::DivisionByZero { span: *span })
-                } else {
-                    compute_series_decimal(&lhs, *val, <ChunkedArray<Float64Type>>::div, lhs_span)
+                Value::Float { val, .. } => {
+                    if val.is_zero() {
+                        Err(ShellError::DivisionByZero { span })
+                    } else {
+                        compute_series_decimal(
+                            &lhs,
+                            *val,
+                            <ChunkedArray<Float64Type>>::div,
+                            lhs_span,
+                        )
+                    }
                 }
+                _ => Err(ShellError::OperatorMismatch {
+                    op_span: operator.span,
+                    lhs_ty: left.get_type().to_string(),
+                    lhs_span: left.span(),
+                    rhs_ty: right.get_type().to_string(),
+                    rhs_span: right.span(),
+                }),
             }
-            _ => Err(ShellError::OperatorMismatch {
-                op_span: operator.span,
-                lhs_ty: left.get_type().to_string(),
-                lhs_span: left.span(),
-                rhs_ty: right.get_type().to_string(),
-                rhs_span: right.span(),
-            }),
-        },
+        }
         Operator::Comparison(Comparison::Equal) => match &right {
             Value::Int { val, .. } => compare_series_i64(&lhs, *val, ChunkedArray::equal, lhs_span),
             Value::Float { val, .. } => {

crates/nu-cmd-dataframe/src/dataframe/values/nu_dataframe/conversion.rs

@@ -452,7 +452,7 @@ fn series_to_values(
 ) -> Result<Vec<Value>, ShellError> {
     match series.dtype() {
         DataType::Null => {
-            let it = std::iter::repeat(Value::Nothing { span });
+            let it = std::iter::repeat(Value::nothing(span));
             let values = if let Some(size) = maybe_size {
                 Either::Left(it.take(size))
             } else {
@@ -480,11 +480,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -508,11 +505,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -536,11 +530,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -564,11 +555,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -592,11 +580,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -620,11 +605,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -648,11 +630,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int {
-                    val: a as i64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a as i64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -676,8 +655,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Int { val: a, span },
-                None => Value::Nothing { span },
+                Some(a) => Value::int(a, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -701,11 +680,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Float {
-                    val: a as f64,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::float(a as f64, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -729,8 +705,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Float { val: a, span },
-                None => Value::Nothing { span },
+                Some(a) => Value::float(a, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -754,8 +730,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::Bool { val: a, span },
-                None => Value::Nothing { span },
+                Some(a) => Value::bool(a, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -779,11 +755,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(a) => Value::String {
-                    val: a.into(),
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(a) => Value::string(a.to_string(), span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -812,7 +785,7 @@ fn series_to_values(
                     }
                     .map(|v| match v {
                         Some(a) => a.get_value(),
-                        None => Value::Nothing { span },
+                        None => Value::nothing(span),
                     })
                     .collect::<Vec<Value>>();
 
@@ -850,10 +823,7 @@ fn series_to_values(
                                     }
                                 })
                                 .unwrap_or(vec![]);
-                            Value::List {
-                                vals: sublist,
-                                span,
-                            }
+                            Value::list(sublist, span)
                         })
                         .collect::<Vec<Value>>();
                     Ok(values)
@@ -884,43 +854,40 @@ fn series_to_values(
                     let naive_datetime = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
                         Some(val) => val,
                         None => {
-                            return Value::Error {
-                                error: Box::new(ShellError::UnsupportedInput(
+                            return Value::error(
+                                ShellError::UnsupportedInput(
                                     "The given local datetime representation is invalid."
                                         .to_string(),
                                     format!("timestamp is {a:?}"),
                                     span,
                                     Span::unknown(),
-                                )),
+                                ),
                                 span,
-                            }
+                            )
                         }
                     };
                     // Zero length offset
                     let offset = match FixedOffset::east_opt(0) {
                         Some(val) => val,
                         None => {
-                            return Value::Error {
-                                error: Box::new(ShellError::UnsupportedInput(
+                            return Value::error(
+                                ShellError::UnsupportedInput(
                                     "The given local datetime representation is invalid."
                                         .to_string(),
                                     format!("timestamp is {a:?}"),
                                     span,
                                     Span::unknown(),
-                                )),
+                                ),
                                 span,
-                            }
+                            )
                         }
                     };
                     let datetime =
                         DateTime::<FixedOffset>::from_naive_utc_and_offset(naive_datetime, offset);
 
-                    Value::Date {
-                        val: datetime,
-                        span,
-                    }
+                    Value::date(datetime, span)
                 }
-                None => Value::Nothing { span },
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -955,43 +922,40 @@ fn series_to_values(
                     let naive_datetime = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
                         Some(val) => val,
                         None => {
-                            return Value::Error {
-                                error: Box::new(ShellError::UnsupportedInput(
+                            return Value::error(
+                                ShellError::UnsupportedInput(
                                     "The given local datetime representation is invalid."
                                         .to_string(),
                                     format!("timestamp is {a:?}"),
                                     span,
                                     Span::unknown(),
-                                )),
+                                ),
                                 span,
-                            }
+                            )
                         }
                     };
                     // Zero length offset
                     let offset = match FixedOffset::east_opt(0) {
                         Some(val) => val,
                         None => {
-                            return Value::Error {
-                                error: Box::new(ShellError::UnsupportedInput(
+                            return Value::error(
+                                ShellError::UnsupportedInput(
                                     "The given local datetime representation is invalid."
                                         .to_string(),
                                     format!("timestamp is {a:?}"),
                                     span,
                                     Span::unknown(),
-                                )),
+                                ),
                                 span,
-                            }
+                            )
                         }
                     };
                     let datetime =
                         DateTime::<FixedOffset>::from_naive_utc_and_offset(naive_datetime, offset);
 
-                    Value::Date {
-                        val: datetime,
-                        span,
-                    }
+                    Value::date(datetime, span)
                 }
-                None => Value::Nothing { span },
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -1015,11 +979,8 @@ fn series_to_values(
                 Either::Right(it)
             }
             .map(|v| match v {
-                Some(nanoseconds) => Value::Duration {
-                    val: nanoseconds,
-                    span,
-                },
-                None => Value::Nothing { span },
+                Some(nanoseconds) => Value::duration(nanoseconds, span),
+                None => Value::nothing(span),
             })
             .collect::<Vec<Value>>();
 
@@ -1043,20 +1004,14 @@ mod tests {
     #[test]
     fn test_parsed_column_string_list() -> Result<(), Box<dyn std::error::Error>> {
         let values = vec![
-            Value::List {
-                vals: vec![Value::String {
-                    val: "bar".to_string(),
-                    span: Span::test_data(),
-                }],
-                span: Span::test_data(),
-            },
-            Value::List {
-                vals: vec![Value::String {
-                    val: "baz".to_string(),
-                    span: Span::test_data(),
-                }],
-                span: Span::test_data(),
-            },
+            Value::list(
+                vec![Value::string("bar".to_string(), Span::test_data())],
+                Span::test_data(),
+            ),
+            Value::list(
+                vec![Value::string("baz".to_string(), Span::test_data())],
+                Span::test_data(),
+            ),
         ];
         let column = Column {
             name: "foo".to_string(),

crates/nu-cmd-dataframe/src/dataframe/values/nu_dataframe/custom_value.rs

@@ -17,10 +17,7 @@ impl CustomValue for NuDataFrame {
             from_lazy: false,
         };
 
-        Value::CustomValue {
-            val: Box::new(cloned),
-            span,
-        }
+        Value::custom_value(Box::new(cloned), span)
     }
 
     fn value_string(&self) -> String {
@@ -30,7 +27,7 @@ impl CustomValue for NuDataFrame {
     fn to_base_value(&self, span: Span) -> Result<Value, ShellError> {
         let vals = self.print(span)?;
 
-        Ok(Value::List { vals, span })
+        Ok(Value::list(vals, span))
     }
 
     fn as_any(&self) -> &dyn std::any::Any {

crates/nu-cmd-dataframe/src/dataframe/values/nu_dataframe/mod.rs

@@ -38,9 +38,7 @@ impl Display for DataFrameValue {
 
 impl Default for DataFrameValue {
     fn default() -> Self {
-        Self(Value::Nothing {
-            span: Span::unknown(),
-        })
+        Self(Value::nothing(Span::unknown()))
     }
 }
 
@@ -111,24 +109,15 @@ impl NuDataFrame {
     }
 
     pub fn dataframe_into_value(dataframe: DataFrame, span: Span) -> Value {
-        Value::CustomValue {
-            val: Box::new(Self::new(false, dataframe)),
-            span,
-        }
+        Value::custom_value(Box::new(Self::new(false, dataframe)), span)
     }
 
     pub fn into_value(self, span: Span) -> Value {
         if self.from_lazy {
             let lazy = NuLazyFrame::from_dataframe(self);
-            Value::CustomValue {
-                val: Box::new(lazy),
-                span,
-            }
+            Value::custom_value(Box::new(lazy), span)
         } else {
-            Value::CustomValue {
-                val: Box::new(self),
-                span,
-            }
+            Value::custom_value(Box::new(self), span)
         }
     }
 
@@ -207,16 +196,19 @@ impl NuDataFrame {
     pub fn fill_list_nan(list: Vec<Value>, list_span: Span, fill: Value) -> Value {
         let newlist = list
             .into_iter()
-            .map(|value| match value {
-                Value::Float { val, .. } => {
-                    if val.is_nan() {
-                        fill.clone()
-                    } else {
-                        value
+            .map(|value| {
+                let span = value.span();
+                match value {
+                    Value::Float { val, .. } => {
+                        if val.is_nan() {
+                            fill.clone()
+                        } else {
+                            value
+                        }
                     }
+                    Value::List { vals, .. } => Self::fill_list_nan(vals, span, fill.clone()),
+                    _ => value,
                 }
-                Value::List { vals, span } => Self::fill_list_nan(vals, span, fill.clone()),
-                _ => value,
             })
             .collect::<Vec<Value>>();
         Value::list(newlist, list_span)
@@ -250,8 +242,9 @@ impl NuDataFrame {
     }
 
     pub fn get_df(value: Value) -> Result<Self, ShellError> {
+        let span = value.span();
         match value {
-            Value::CustomValue { val, span } => match val.as_any().downcast_ref::<Self>() {
+            Value::CustomValue { val, .. } => match val.as_any().downcast_ref::<Self>() {
                 Some(df) => Ok(NuDataFrame {
                     df: df.df.clone(),
                     from_lazy: false,

crates/nu-cmd-dataframe/src/dataframe/values/nu_dataframe/operations.rs

@@ -20,15 +20,13 @@ impl NuDataFrame {
         op_span: Span,
         right: &Value,
     ) -> Result<Value, ShellError> {
+        let rhs_span = right.span();
         match right {
-            Value::CustomValue {
-                val: rhs,
-                span: rhs_span,
-            } => {
+            Value::CustomValue { val: rhs, .. } => {
                 let rhs = rhs.as_any().downcast_ref::<NuDataFrame>().ok_or_else(|| {
                     ShellError::DowncastNotPossible(
                         "Unable to create dataframe".to_string(),
-                        *rhs_span,
+                        rhs_span,
                     )
                 })?;
 
@@ -38,7 +36,7 @@ impl NuDataFrame {
                             .as_series(lhs_span)
                             .expect("Already checked that is a series");
                         let rhs = &rhs
-                            .as_series(*rhs_span)
+                            .as_series(rhs_span)
                             .expect("Already checked that is a series");
 
                         if lhs.dtype() != rhs.dtype() {
@@ -46,7 +44,7 @@ impl NuDataFrame {
                                 left_message: format!("datatype {}", lhs.dtype()),
                                 left_span: lhs_span,
                                 right_message: format!("datatype {}", lhs.dtype()),
-                                right_span: *rhs_span,
+                                right_span: rhs_span,
                             });
                         }
 
@@ -55,7 +53,7 @@ impl NuDataFrame {
                                 left_message: format!("len {}", lhs.len()),
                                 left_span: lhs_span,
                                 right_message: format!("len {}", rhs.len()),
-                                right_span: *rhs_span,
+                                right_span: rhs_span,
                             });
                         }
 
@@ -78,7 +76,7 @@ impl NuDataFrame {
                                 left_message: format!("rows {}", self.df.height()),
                                 left_span: lhs_span,
                                 right_message: format!("rows {}", rhs.df.height()),
-                                right_span: *rhs_span,
+                                right_span: rhs_span,
                             });
                         }
 

crates/nu-cmd-dataframe/src/dataframe/values/nu_expression/custom_value.rs

@@ -20,10 +20,7 @@ impl CustomValue for NuExpression {
     fn clone_value(&self, span: nu_protocol::Span) -> Value {
         let cloned = NuExpression(self.0.clone());
 
-        Value::CustomValue {
-            val: Box::new(cloned),
-            span,
-        }
+        Value::custom_value(Box::new(cloned), span)
     }
 
     fn value_string(&self) -> String {
@@ -56,16 +53,11 @@ fn compute_with_value(
     op: Span,
     right: &Value,
 ) -> Result<Value, ShellError> {
+    let rhs_span = right.span();
     match right {
-        Value::CustomValue {
-            val: rhs,
-            span: rhs_span,
-        } => {
+        Value::CustomValue { val: rhs, .. } => {
             let rhs = rhs.as_any().downcast_ref::<NuExpression>().ok_or_else(|| {
-                ShellError::DowncastNotPossible(
-                    "Unable to create expression".to_string(),
-                    *rhs_span,
-                )
+                ShellError::DowncastNotPossible("Unable to create expression".to_string(), rhs_span)
             })?;
 
             match rhs.as_ref() {

crates/nu-cmd-dataframe/src/dataframe/values/nu_expression/mod.rs

@@ -55,15 +55,13 @@ impl From<Expr> for NuExpression {
 
 impl NuExpression {
     pub fn into_value(self, span: Span) -> Value {
-        Value::CustomValue {
-            val: Box::new(self),
-            span,
-        }
+        Value::custom_value(Box::new(self), span)
     }
 
     pub fn try_from_value(value: Value) -> Result<Self, ShellError> {
+        let span = value.span();
         match value {
-            Value::CustomValue { val, span } => match val.as_any().downcast_ref::<Self>() {
+            Value::CustomValue { val, .. } => match val.as_any().downcast_ref::<Self>() {
                 Some(expr) => Ok(NuExpression(expr.0.clone())),
                 None => Err(ShellError::CantConvert {
                     to_type: "lazy expression".into(),
@@ -277,13 +275,10 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Result<Value, ShellError> {
         Expr::DtypeColumn(dtypes) => {
             let vals = dtypes
                 .iter()
-                .map(|d| Value::String {
-                    val: format!("{d}"),
-                    span,
-                })
+                .map(|d| Value::string(format!("{d}"), span))
                 .collect();
 
-            Ok(Value::List { vals, span })
+            Ok(Value::list(vals, span))
         }
         Expr::Sort { expr, options } => Ok(Value::record(
             record! {
@@ -318,10 +313,7 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Result<Value, ShellError> {
         } => {
             let by: Result<Vec<Value>, ShellError> =
                 by.iter().map(|b| expr_to_value(b, span)).collect();
-            let descending: Vec<Value> = descending
-                .iter()
-                .map(|r| Value::Bool { val: *r, span })
-                .collect();
+            let descending: Vec<Value> = descending.iter().map(|r| Value::bool(*r, span)).collect();
 
             Ok(Value::record(
                 record! {
@@ -354,10 +346,7 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Result<Value, ShellError> {
         Expr::Exclude(expr, excluded) => {
             let excluded = excluded
                 .iter()
-                .map(|e| Value::String {
-                    val: format!("{e:?}"),
-                    span,
-                })
+                .map(|e| Value::string(format!("{e:?}"), span))
                 .collect();
 
             Ok(Value::record(

crates/nu-cmd-dataframe/src/dataframe/values/nu_lazyframe/custom_value.rs

@@ -18,10 +18,7 @@ impl CustomValue for NuLazyFrame {
             schema: self.schema.clone(),
         };
 
-        Value::CustomValue {
-            val: Box::new(cloned),
-            span,
-        }
+        Value::custom_value(Box::new(cloned), span)
     }
 
     fn value_string(&self) -> String {

crates/nu-cmd-dataframe/src/dataframe/values/nu_lazyframe/mod.rs

@@ -90,15 +90,9 @@ impl NuLazyFrame {
     pub fn into_value(self, span: Span) -> Result<Value, ShellError> {
         if self.from_eager {
             let df = self.collect(span)?;
-            Ok(Value::CustomValue {
-                val: Box::new(df),
-                span,
-            })
+            Ok(Value::custom_value(Box::new(df), span))
         } else {
-            Ok(Value::CustomValue {
-                val: Box::new(self),
-                span,
-            })
+            Ok(Value::custom_value(Box::new(self), span))
         }
     }
 
@@ -147,8 +141,9 @@ impl NuLazyFrame {
     }
 
     pub fn get_lazy_df(value: Value) -> Result<Self, ShellError> {
+        let span = value.span();
         match value {
-            Value::CustomValue { val, span } => match val.as_any().downcast_ref::<Self>() {
+            Value::CustomValue { val, .. } => match val.as_any().downcast_ref::<Self>() {
                 Some(expr) => Ok(Self {
                     lazy: expr.lazy.clone(),
                     from_eager: false,

crates/nu-cmd-dataframe/src/dataframe/values/nu_lazygroupby/custom_value.rs

@@ -18,10 +18,7 @@ impl CustomValue for NuLazyGroupBy {
             from_eager: self.from_eager,
         };
 
-        Value::CustomValue {
-            val: Box::new(cloned),
-            span,
-        }
+        Value::custom_value(Box::new(cloned), span)
     }
 
     fn value_string(&self) -> String {

crates/nu-cmd-dataframe/src/dataframe/values/nu_lazygroupby/mod.rs

@@ -74,10 +74,7 @@ impl From<LazyGroupBy> for NuLazyGroupBy {
 
 impl NuLazyGroupBy {
     pub fn into_value(self, span: Span) -> Value {
-        Value::CustomValue {
-            val: Box::new(self),
-            span,
-        }
+        Value::custom_value(Box::new(self), span)
     }
 
     pub fn into_polars(self) -> LazyGroupBy {
@@ -85,22 +82,21 @@ impl NuLazyGroupBy {
     }
 
     pub fn try_from_value(value: Value) -> Result<Self, ShellError> {
+        let span = value.span();
         match value {
-            Value::CustomValue { val, span } => {
-                match val.as_any().downcast_ref::<NuLazyGroupBy>() {
-                    Some(group) => Ok(Self {
-                        group_by: group.group_by.clone(),
-                        schema: group.schema.clone(),
-                        from_eager: group.from_eager,
-                    }),
-                    None => Err(ShellError::CantConvert {
-                        to_type: "lazy groupby".into(),
-                        from_type: "custom value".into(),
-                        span,
-                        help: None,
-                    }),
-                }
-            }
+            Value::CustomValue { val, .. } => match val.as_any().downcast_ref::<NuLazyGroupBy>() {
+                Some(group) => Ok(Self {
+                    group_by: group.group_by.clone(),
+                    schema: group.schema.clone(),
+                    from_eager: group.from_eager,
+                }),
+                None => Err(ShellError::CantConvert {
+                    to_type: "lazy groupby".into(),
+                    from_type: "custom value".into(),
+                    span,
+                    help: None,
+                }),
+            },
             x => Err(ShellError::CantConvert {
                 to_type: "lazy groupby".into(),
                 from_type: x.get_type().to_string(),

crates/nu-cmd-dataframe/src/dataframe/values/nu_when/custom_value.rs

@@ -14,10 +14,7 @@ impl CustomValue for NuWhen {
     fn clone_value(&self, span: nu_protocol::Span) -> Value {
         let cloned = self.clone();
 
-        Value::CustomValue {
-            val: Box::new(cloned),
-            span,
-        }
+        Value::custom_value(Box::new(cloned), span)
     }
 
     fn value_string(&self) -> String {
@@ -25,12 +22,12 @@ impl CustomValue for NuWhen {
     }
 
     fn to_base_value(&self, span: Span) -> Result<Value, ShellError> {
-        let val = match self {
+        let val: String = match self {
             NuWhen::Then(_) => "whenthen".into(),
             NuWhen::ChainedThen(_) => "whenthenthen".into(),
         };
 
-        let value = Value::String { val, span };
+        let value = Value::string(val, span);
         Ok(value)
     }
 

crates/nu-cmd-dataframe/src/dataframe/values/nu_when/mod.rs

@@ -51,15 +51,13 @@ impl From<ChainedThen> for NuWhen {
 
 impl NuWhen {
     pub fn into_value(self, span: Span) -> Value {
-        Value::CustomValue {
-            val: Box::new(self),
-            span,
-        }
+        Value::custom_value(Box::new(self), span)
     }
 
     pub fn try_from_value(value: Value) -> Result<Self, ShellError> {
+        let span = value.span();
         match value {
-            Value::CustomValue { val, span } => match val.as_any().downcast_ref::<Self>() {
+            Value::CustomValue { val, .. } => match val.as_any().downcast_ref::<Self>() {
                 Some(expr) => Ok(expr.clone()),
                 None => Err(ShellError::CantConvert {
                     to_type: "when expression".into(),

crates/nu-cmd-dataframe/src/dataframe/values/utils.rs

@@ -25,18 +25,21 @@ pub(crate) fn convert_columns(
 
     let res = columns
         .into_iter()
-        .map(|value| match value {
-            Value::String { val, span } => {
-                col_span = span_join(&[col_span, span]);
-                Ok(Spanned { item: val, span })
+        .map(|value| {
+            let span = value.span();
+            match value {
+                Value::String { val, .. } => {
+                    col_span = span_join(&[col_span, span]);
+                    Ok(Spanned { item: val, span })
+                }
+                _ => Err(ShellError::GenericError(
+                    "Incorrect column format".into(),
+                    "Only string as column name".into(),
+                    Some(span),
+                    None,
+                    Vec::new(),
+                )),
             }
-            _ => Err(ShellError::GenericError(
-                "Incorrect column format".into(),
-                "Only string as column name".into(),
-                Some(span),
-                None,
-                Vec::new(),
-            )),
         })
         .collect::<Result<Vec<Spanned<String>>, _>>()?;
 
@@ -65,18 +68,21 @@ pub(crate) fn convert_columns_string(
 
     let res = columns
         .into_iter()
-        .map(|value| match value {
-            Value::String { val, span } => {
-                col_span = span_join(&[col_span, span]);
-                Ok(val)
+        .map(|value| {
+            let span = value.span();
+            match value {
+                Value::String { val, .. } => {
+                    col_span = span_join(&[col_span, span]);
+                    Ok(val)
+                }
+                _ => Err(ShellError::GenericError(
+                    "Incorrect column format".into(),
+                    "Only string as column name".into(),
+                    Some(span),
+                    None,
+                    Vec::new(),
+                )),
             }
-            _ => Err(ShellError::GenericError(
-                "Incorrect column format".into(),
-                "Only string as column name".into(),
-                Some(span),
-                None,
-                Vec::new(),
-            )),
         })
         .collect::<Result<Vec<String>, _>>()?;