Remove Record::from_raw_cols_vals_unchecked (#11810)

# Description
Follows from #11718 and replaces all usages of
`Record::from_raw_cols_vals_unchecked` with iterator or `record!`
equivalents.

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

@@ -5,7 +5,7 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, Record, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    record, Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 use polars::prelude::*;
 
@@ -52,13 +52,10 @@ impl Command for CastDF {
                 description: "Cast a column in a dataframe to a different dtype",
                 example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr cast u8 a | dfr schema",
                 result: Some(Value::record(
-                    Record::from_raw_cols_vals_unchecked(
-                        vec!["a".to_string(), "b".to_string()],
-                        vec![
-                            Value::string("u8", Span::test_data()),
-                            Value::string("i64", Span::test_data()),
-                        ],
-                    ),
+                    record! {
+                        "a" => Value::string("u8", Span::test_data()),
+                        "b" => Value::string("i64", Span::test_data()),
+                    },
                     Span::test_data(),
                 )),
             },
@@ -66,13 +63,10 @@ impl Command for CastDF {
                 description: "Cast a column in a lazy dataframe to a different dtype",
                 example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr into-lazy | dfr cast u8 a | dfr schema",
                 result: Some(Value::record(
-                    Record::from_raw_cols_vals_unchecked(
-                        vec!["a".to_string(), "b".to_string()],
-                        vec![
-                            Value::string("u8", Span::test_data()),
-                            Value::string("i64", Span::test_data()),
-                        ],
-                    ),
+                    record! {
+                        "a" => Value::string("u8", Span::test_data()),
+                        "b" => Value::string("i64", Span::test_data()),
+                    },
                     Span::test_data(),
                 )),
             },

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

@@ -3,7 +3,7 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, Record, ShellError, Signature, Span, Type, Value,
+    record, Category, Example, PipelineData, ShellError, Signature, Span, Type, Value,
 };
 
 #[derive(Clone)]
@@ -33,13 +33,10 @@ impl Command for SchemaDF {
             description: "Dataframe schema",
             example: r#"[[a b]; [1 "foo"] [3 "bar"]] | dfr into-df | dfr schema"#,
             result: Some(Value::record(
-                Record::from_raw_cols_vals_unchecked(
-                    vec!["a".to_string(), "b".to_string()],
-                    vec![
-                        Value::string("i64", Span::test_data()),
-                        Value::string("str", Span::test_data()),
-                    ],
-                ),
+                record! {
+                    "a" => Value::string("i64", Span::test_data()),
+                    "b" => Value::string("str", Span::test_data()),
+                },
                 Span::test_data(),
             )),
         }]
@@ -98,10 +95,11 @@ fn datatype_list(span: Span) -> Value {
     ]
     .iter()
     .map(|(dtype, note)| {
-        Value::record(Record::from_raw_cols_vals_unchecked(
-            vec!["dtype".to_string(), "note".to_string()],
-            vec![Value::string(*dtype, span), Value::string(*note, span)],
-        ),span)
+        Value::record(record! {
+            "dtype" => Value::string(*dtype, span),
+            "note" => Value::string(*note, span),
+        },
+        span)
     })
     .collect();
     Value::list(types, span)

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

@@ -1033,15 +1033,14 @@ fn series_to_values(
                     Either::Right(it)
                 }
                 .map(|any_values| {
-                    let vals: Result<Vec<Value>, ShellError> = any_values
+                    let record = polar_fields
                         .iter()
-                        .map(|v| any_value_to_value(v, span))
-                        .collect();
-                    let cols: Vec<String> = polar_fields
-                        .iter()
-                        .map(|field| field.name.to_string())
-                        .collect();
-                    let record = Record::from_raw_cols_vals_unchecked(cols, vals?);
+                        .zip(any_values)
+                        .map(|(field, val)| {
+                            any_value_to_value(val, span).map(|val| (field.name.to_string(), val))
+                        })
+                        .collect::<Result<_, _>>()?;
+
                     Ok(Value::record(record, span))
                 })
                 .collect();
@@ -1138,20 +1137,16 @@ fn any_value_to_value(any_value: &AnyValue, span: Span) -> Result<Value, ShellEr
             any_value_to_value(&static_value, span)
         }
         AnyValue::StructOwned(struct_tuple) => {
-            let values: Result<Vec<Value>, ShellError> = struct_tuple
-                .0
-                .iter()
-                .map(|s| any_value_to_value(s, span))
-                .collect();
-            let fields = struct_tuple
+            let record = struct_tuple
                 .1
                 .iter()
-                .map(|f| f.name().to_string())
-                .collect();
-            Ok(Value::Record {
-                val: Record::from_raw_cols_vals_unchecked(fields, values?),
-                internal_span: span,
-            })
+                .zip(&struct_tuple.0)
+                .map(|(field, val)| {
+                    any_value_to_value(val, span).map(|val| (field.name.to_string(), val))
+                })
+                .collect::<Result<_, _>>()?;
+
+            Ok(Value::record(record, span))
         }
         AnyValue::StringOwned(s) => Ok(Value::string(s.to_string(), span)),
         AnyValue::Binary(bytes) => Ok(Value::binary(*bytes, span)),

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

@@ -154,15 +154,13 @@ impl NuDataFrame {
             match value {
                 Value::CustomValue { .. } => return Self::try_from_value(value),
                 Value::List { vals, .. } => {
-                    let cols = (0..vals.len())
-                        .map(|i| format!("{i}"))
-                        .collect::<Vec<String>>();
+                    let record = vals
+                        .into_iter()
+                        .enumerate()
+                        .map(|(i, val)| (format!("{i}"), val))
+                        .collect();
 
-                    conversion::insert_record(
-                        &mut column_values,
-                        Record::from_raw_cols_vals_unchecked(cols, vals),
-                        &maybe_schema,
-                    )?
+                    conversion::insert_record(&mut column_values, record, &maybe_schema)?
                 }
                 Value::Record { val: record, .. } => {
                     conversion::insert_record(&mut column_values, record, &maybe_schema)?

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

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use nu_protocol::{Record, ShellError, Span, Value};
+use nu_protocol::{ShellError, Span, Value};
 use polars::prelude::{DataType, Field, Schema, SchemaRef, TimeUnit};
 
 #[derive(Debug, Clone)]
@@ -37,15 +37,14 @@ impl From<NuSchema> for SchemaRef {
 }
 
 fn fields_to_value(fields: impl Iterator<Item = Field>, span: Span) -> Value {
-    let (cols, vals) = fields
+    let record = fields
         .map(|field| {
-            let val = dtype_to_value(field.data_type(), span);
             let col = field.name().to_string();
+            let val = dtype_to_value(field.data_type(), span);
             (col, val)
         })
-        .unzip();
+        .collect();
 
-    let record = Record::from_raw_cols_vals_unchecked(cols, vals);
     Value::record(record, Span::unknown())
 }
 
@@ -188,42 +187,23 @@ fn str_to_time_unit(ts_string: &str, span: Span) -> Result<TimeUnit, ShellError>
 #[cfg(test)]
 mod test {
 
+    use nu_protocol::record;
+
     use super::*;
 
     #[test]
     fn test_value_to_schema() {
-        let value = Value::Record {
-            val: Record::from_raw_cols_vals_unchecked(
-                vec!["name".into(), "age".into(), "address".into()],
-                vec![
-                    Value::String {
-                        val: "str".into(),
-                        internal_span: Span::test_data(),
-                    },
-                    Value::String {
-                        val: "i32".into(),
-                        internal_span: Span::test_data(),
-                    },
-                    Value::Record {
-                        val: Record::from_raw_cols_vals_unchecked(
-                            vec!["street".into(), "city".into()],
-                            vec![
-                                Value::String {
-                                    val: "str".into(),
-                                    internal_span: Span::test_data(),
-                                },
-                                Value::String {
-                                    val: "str".into(),
-                                    internal_span: Span::test_data(),
-                                },
-                            ],
-                        ),
-                        internal_span: Span::test_data(),
-                    },
-                ],
-            ),
-            internal_span: Span::test_data(),
+        let address = record! {
+            "street" => Value::test_string("str"),
+            "city" => Value::test_string("str"),
         };
+
+        let value = Value::test_record(record! {
+            "name" => Value::test_string("str"),
+            "age" => Value::test_string("i32"),
+            "address" => Value::test_record(address)
+        });
+
         let schema = value_to_schema(&value, Span::unknown()).unwrap();
         let expected = Schema::from_iter(vec![
             Field::new("name", DataType::String),