Add functions for each Value case (#9736)

# Description
This PR ensures functions exist to extract and create each and every
`Value` case. It also renames `Value::boolean` to `Value::bool` to match
`Value::test_bool`, `Value::as_bool`, and `Value::Bool`. Similarly,
`Value::as_integer` was renamed to `Value::as_int` to be consistent with
`Value::int`, `Value::test_int`, and `Value::Int`. These two renames can
be undone if necessary.

# User-Facing Changes
No user facing changes, but two public functions were renamed which may
affect downstream dependents.

crates/nu-cli/src/menus/menu_completions.rs

@@ -94,10 +94,10 @@ fn convert_to_suggestions(
                 Some(span @ Value::Record { .. }) => {
                     let start = span
                         .get_data_by_key("start")
-                        .and_then(|val| val.as_integer().ok());
+                        .and_then(|val| val.as_int().ok());
                     let end = span
                         .get_data_by_key("end")
-                        .and_then(|val| val.as_integer().ok());
+                        .and_then(|val| val.as_int().ok());
                     match (start, end) {
                         (Some(start), Some(end)) => {
                             let start = start.min(end);

crates/nu-cli/src/reedline_config.rs

@@ -183,7 +183,7 @@ pub(crate) fn add_columnar_menu(
     if let Value::Record { cols, vals, span } = &menu.menu_type {
         columnar_menu = match extract_value("columns", cols, vals, span) {
             Ok(columns) => {
-                let columns = columns.as_integer()?;
+                let columns = columns.as_int()?;
                 columnar_menu.with_columns(columns as u16)
             }
             Err(_) => columnar_menu,
@@ -191,7 +191,7 @@ pub(crate) fn add_columnar_menu(
 
         columnar_menu = match extract_value("col_width", cols, vals, span) {
             Ok(col_width) => {
-                let col_width = col_width.as_integer()?;
+                let col_width = col_width.as_int()?;
                 columnar_menu.with_column_width(Some(col_width as usize))
             }
             Err(_) => columnar_menu.with_column_width(None),
@@ -199,7 +199,7 @@ pub(crate) fn add_columnar_menu(
 
         columnar_menu = match extract_value("col_padding", cols, vals, span) {
             Ok(col_padding) => {
-                let col_padding = col_padding.as_integer()?;
+                let col_padding = col_padding.as_int()?;
                 columnar_menu.with_column_padding(col_padding as usize)
             }
             Err(_) => columnar_menu,
@@ -285,7 +285,7 @@ pub(crate) fn add_list_menu(
     if let Value::Record { cols, vals, span } = &menu.menu_type {
         list_menu = match extract_value("page_size", cols, vals, span) {
             Ok(page_size) => {
-                let page_size = page_size.as_integer()?;
+                let page_size = page_size.as_int()?;
                 list_menu.with_page_size(page_size as usize)
             }
             Err(_) => list_menu,
@@ -371,7 +371,7 @@ pub(crate) fn add_description_menu(
     if let Value::Record { cols, vals, span } = &menu.menu_type {
         description_menu = match extract_value("columns", cols, vals, span) {
             Ok(columns) => {
-                let columns = columns.as_integer()?;
+                let columns = columns.as_int()?;
                 description_menu.with_columns(columns as u16)
             }
             Err(_) => description_menu,
@@ -379,7 +379,7 @@ pub(crate) fn add_description_menu(
 
         description_menu = match extract_value("col_width", cols, vals, span) {
             Ok(col_width) => {
-                let col_width = col_width.as_integer()?;
+                let col_width = col_width.as_int()?;
                 description_menu.with_column_width(Some(col_width as usize))
             }
             Err(_) => description_menu.with_column_width(None),
@@ -387,7 +387,7 @@ pub(crate) fn add_description_menu(
 
         description_menu = match extract_value("col_padding", cols, vals, span) {
             Ok(col_padding) => {
-                let col_padding = col_padding.as_integer()?;
+                let col_padding = col_padding.as_int()?;
                 description_menu.with_column_padding(col_padding as usize)
             }
             Err(_) => description_menu,
@@ -395,7 +395,7 @@ pub(crate) fn add_description_menu(
 
         description_menu = match extract_value("selection_rows", cols, vals, span) {
             Ok(selection_rows) => {
-                let selection_rows = selection_rows.as_integer()?;
+                let selection_rows = selection_rows.as_int()?;
                 description_menu.with_selection_rows(selection_rows as u16)
             }
             Err(_) => description_menu,
@@ -403,7 +403,7 @@ pub(crate) fn add_description_menu(
 
         description_menu = match extract_value("description_rows", cols, vals, span) {
             Ok(description_rows) => {
-                let description_rows = description_rows.as_integer()?;
+                let description_rows = description_rows.as_int()?;
                 description_menu.with_description_rows(description_rows as usize)
             }
             Err(_) => description_menu,
@@ -884,7 +884,7 @@ fn edit_from_record(
         "movebigwordrightstart" => EditCommand::MoveBigWordRightStart,
         "movetoposition" => {
             let value = extract_value("value", cols, vals, span)?;
-            EditCommand::MoveToPosition(value.as_integer()? as usize)
+            EditCommand::MoveToPosition(value.as_int()? as usize)
         }
         "insertchar" => {
             let value = extract_value("value", cols, vals, span)?;

crates/nu-cli/src/repl.rs

@@ -538,14 +538,14 @@ pub fn evaluate_repl(
 
                     let current_shell = stack.get_env_var(engine_state, "NUSHELL_CURRENT_SHELL");
                     let current_shell = if let Some(v) = current_shell {
-                        v.as_integer().unwrap_or_default() as usize
+                        v.as_int().unwrap_or_default() as usize
                     } else {
                         0
                     };
 
                     let last_shell = stack.get_env_var(engine_state, "NUSHELL_LAST_SHELL");
                     let last_shell = if let Some(v) = last_shell {
-                        v.as_integer().unwrap_or_default() as usize
+                        v.as_int().unwrap_or_default() as usize
                     } else {
                         0
                     };

crates/nu-cmd-dataframe/src/dataframe/series/all_false.rs

@@ -88,7 +88,7 @@ fn command(
         )
     })?;
 
-    let value = Value::boolean(!bool.any(), call.head);
+    let value = Value::bool(!bool.any(), call.head);
 
     NuDataFrame::try_from_columns(vec![Column::new("all_false".to_string(), vec![value])])
         .map(|df| PipelineData::Value(NuDataFrame::into_value(df, call.head), None))

crates/nu-cmd-dataframe/src/dataframe/series/all_true.rs

@@ -88,7 +88,7 @@ fn command(
         )
     })?;
 
-    let value = Value::boolean(bool.all(), call.head);
+    let value = Value::bool(bool.all(), call.head);
 
     NuDataFrame::try_from_columns(vec![Column::new("all_true".to_string(), vec![value])])
         .map(|df| PipelineData::Value(NuDataFrame::into_value(df, call.head), None))

crates/nu-cmd-extra/src/extra/bytes/ends_with.rs

@@ -89,7 +89,7 @@ fn ends_with(val: &Value, args: &Arguments, span: Span) -> Value {
         Value::Binary {
             val,
             span: val_span,
-        } => Value::boolean(val.ends_with(&args.pattern), *val_span),
+        } => Value::bool(val.ends_with(&args.pattern), *val_span),
         // Propagate errors by explicitly matching them before the final case.
         Value::Error { .. } => val.clone(),
         other => Value::Error {

crates/nu-cmd-extra/src/extra/bytes/starts_with.rs

@@ -98,16 +98,16 @@ impl Command for BytesStartsWith {
                         i += max;
 
                         if i >= arg.pattern.len() {
-                            return Ok(Value::boolean(true, span).into_pipeline_data());
+                            return Ok(Value::bool(true, span).into_pipeline_data());
                         }
                     } else {
-                        return Ok(Value::boolean(false, span).into_pipeline_data());
+                        return Ok(Value::bool(false, span).into_pipeline_data());
                     }
                 }
 
                 // We reached the end of the stream and never returned,
                 // the pattern wasn't exhausted so it probably doesn't match
-                Ok(Value::boolean(false, span).into_pipeline_data())
+                Ok(Value::bool(false, span).into_pipeline_data())
             }
             _ => operate(
                 starts_with,
@@ -145,7 +145,7 @@ fn starts_with(val: &Value, args: &Arguments, span: Span) -> Value {
         Value::Binary {
             val,
             span: val_span,
-        } => Value::boolean(val.starts_with(&args.pattern), *val_span),
+        } => Value::bool(val.starts_with(&args.pattern), *val_span),
         // Propagate errors by explicitly matching them before the final case.
         Value::Error { .. } => val.clone(),
         other => Value::Error {

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

@@ -59,27 +59,27 @@ impl Command for SubCommand {
                     vals: vec![
                         Value::Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::boolean(false, span)],
+                            vals: vec![Value::bool(false, span)],
                             span,
                         },
                         Value::Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::boolean(true, span)],
+                            vals: vec![Value::bool(true, span)],
                             span,
                         },
                         Value::Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::boolean(false, span)],
+                            vals: vec![Value::bool(false, span)],
                             span,
                         },
                         Value::Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::boolean(true, span)],
+                            vals: vec![Value::bool(true, span)],
                             span,
                         },
                         Value::Record {
                             cols: vec!["value".to_string()],
-                            vals: vec![Value::boolean(true, span)],
+                            vals: vec![Value::bool(true, span)],
                             span,
                         },
                     ],
@@ -89,27 +89,27 @@ impl Command for SubCommand {
             Example {
                 description: "Convert bool to boolean",
                 example: "true | into bool",
-                result: Some(Value::boolean(true, span)),
+                result: Some(Value::bool(true, span)),
             },
             Example {
                 description: "convert integer to boolean",
                 example: "1 | into bool",
-                result: Some(Value::boolean(true, span)),
+                result: Some(Value::bool(true, span)),
             },
             Example {
                 description: "convert decimal to boolean",
                 example: "0.3 | into bool",
-                result: Some(Value::boolean(true, span)),
+                result: Some(Value::bool(true, span)),
             },
             Example {
                 description: "convert decimal string to boolean",
                 example: "'0.0' | into bool",
-                result: Some(Value::boolean(false, span)),
+                result: Some(Value::bool(false, span)),
             },
             Example {
                 description: "convert string to boolean",
                 example: "'true' | into bool",
-                result: Some(Value::boolean(true, span)),
+                result: Some(Value::bool(true, span)),
             },
         ]
     }

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

@@ -52,7 +52,7 @@ impl Command for SubCommand {
                 example: "[[value]; [false]] | into record",
                 result: Some(Value::Record {
                     cols: vec!["value".to_string()],
-                    vals: vec![Value::boolean(false, span)],
+                    vals: vec![Value::bool(false, span)],
                     span,
                 }),
             },

crates/nu-command/src/experimental/is_admin.rs

@@ -34,7 +34,7 @@ impl Command for IsAdmin {
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        Ok(Value::boolean(is_root(), call.head).into_pipeline_data())
+        Ok(Value::bool(is_root(), call.head).into_pipeline_data())
     }
 
     fn examples(&self) -> Vec<Example> {

crates/nu-command/src/filters/drop/nth.rs

@@ -118,8 +118,8 @@ impl Command for DropNth {
                 rows
             }
             Either::Right(row_range) => {
-                let from = row_range.from.as_integer()?; // as usize;
+                let from = row_range.from.as_int()?; // as usize;
-                let to = row_range.to.as_integer()?; // as usize;
+                let to = row_range.to.as_int()?; // as usize;
 
                 // check for negative range inputs, e.g., (2..-5)
                 if from.is_negative() || to.is_negative() {
@@ -187,7 +187,7 @@ fn extract_int_or_range(
 ) -> Result<Either<i64, Range>, ShellError> {
     let value = call.req::<Value>(engine_state, stack, 0)?;
 
-    let int_opt = value.as_integer().map(Either::Left).ok();
+    let int_opt = value.as_int().map(Either::Left).ok();
     let range_opt: Result<nu_protocol::Range, ShellError> = FromValue::from_value(&value);
 
     let range_opt = range_opt.map(Either::Right).ok();

crates/nu-command/src/filters/empty.rs

@@ -76,13 +76,13 @@ fn empty(
                 let val = val.clone();
                 match val.follow_cell_path(&column.members, false) {
                     Ok(Value::Nothing { .. }) => {}
-                    Ok(_) => return Ok(Value::boolean(false, head).into_pipeline_data()),
+                    Ok(_) => return Ok(Value::bool(false, head).into_pipeline_data()),
                     Err(err) => return Err(err),
                 }
             }
         }
 
-        Ok(Value::boolean(true, head).into_pipeline_data())
+        Ok(Value::bool(true, head).into_pipeline_data())
     } else {
         match input {
             PipelineData::Empty => Ok(PipelineData::Empty),
@@ -91,17 +91,17 @@ fn empty(
                     let bytes = s.into_bytes();
 
                     match bytes {
-                        Ok(s) => Ok(Value::boolean(s.item.is_empty(), head).into_pipeline_data()),
+                        Ok(s) => Ok(Value::bool(s.item.is_empty(), head).into_pipeline_data()),
                         Err(err) => Err(err),
                     }
                 }
-                None => Ok(Value::boolean(true, head).into_pipeline_data()),
+                None => Ok(Value::bool(true, head).into_pipeline_data()),
             },
             PipelineData::ListStream(s, ..) => {
-                Ok(Value::boolean(s.count() == 0, head).into_pipeline_data())
+                Ok(Value::bool(s.count() == 0, head).into_pipeline_data())
             }
             PipelineData::Value(value, ..) => {
-                Ok(Value::boolean(value.is_empty(), head).into_pipeline_data())
+                Ok(Value::bool(value.is_empty(), head).into_pipeline_data())
             }
         }
     }

crates/nu-command/src/formats/from/ods.rs

@@ -145,7 +145,7 @@ fn from_ods(
                         DataType::String(s) => Value::string(s, head),
                         DataType::Float(f) => Value::float(*f, head),
                         DataType::Int(i) => Value::int(*i, head),
-                        DataType::Bool(b) => Value::boolean(*b, head),
+                        DataType::Bool(b) => Value::bool(*b, head),
                         _ => Value::nothing(head),
                     };
 

crates/nu-command/src/formats/from/xlsx.rs

@@ -144,7 +144,7 @@ fn from_xlsx(
                         DataType::String(s) => Value::string(s, head),
                         DataType::Float(f) => Value::float(*f, head),
                         DataType::Int(i) => Value::int(*i, head),
-                        DataType::Bool(b) => Value::boolean(*b, head),
+                        DataType::Bool(b) => Value::bool(*b, head),
                         _ => Value::nothing(head),
                     };
 

crates/nu-command/src/random/integer.rs

@@ -77,9 +77,9 @@ fn integer(
 
     let (min, max) = if let Some(r) = range {
         if r.is_end_inclusive() {
-            (r.from.as_integer()?, r.to.as_integer()?)
+            (r.from.as_int()?, r.to.as_int()?)
-        } else if r.to.as_integer()? > 0 {
+        } else if r.to.as_int()? > 0 {
-            (r.from.as_integer()?, r.to.as_integer()? - 1)
+            (r.from.as_int()?, r.to.as_int()? - 1)
         } else {
             (0, 0)
         }

crates/nu-command/src/strings/str_/contains.rs

@@ -164,7 +164,7 @@ fn action(
     head: Span,
 ) -> Value {
     match input {
-        Value::String { val, .. } => Value::boolean(
+        Value::String { val, .. } => Value::bool(
             match case_insensitive {
                 true => {
                     if *not_contain {

crates/nu-command/src/strings/str_/ends_with.rs

@@ -94,7 +94,7 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
             } else {
                 s.ends_with(&args.substring)
             };
-            Value::boolean(ends_with, head)
+            Value::bool(ends_with, head)
         }
         Value::Error { .. } => input.clone(),
         _ => Value::Error {

crates/nu-command/src/strings/str_/starts_with.rs

@@ -110,7 +110,7 @@ fn action(
             } else {
                 s.starts_with(substring)
             };
-            Value::boolean(starts_with, head)
+            Value::bool(starts_with, head)
         }
         Value::Error { .. } => input.clone(),
         _ => Value::Error {

crates/nu-command/src/system/nu_check.rs

@@ -246,7 +246,7 @@ fn heuristic_parse(
                             Vec::new(),
                         ))
                     } else {
-                        Ok(PipelineData::Value(Value::boolean(false, span), None))
+                        Ok(PipelineData::Value(Value::bool(false, span), None))
                     }
                 }
             }
@@ -291,7 +291,7 @@ fn heuristic_parse_file(
                                     Vec::new(),
                                 ))
                             } else {
-                                Ok(PipelineData::Value(Value::boolean(false, call.head), None))
+                                Ok(PipelineData::Value(Value::bool(false, call.head), None))
                             }
                         }
                     }
@@ -337,10 +337,10 @@ fn parse_module(
                 Vec::new(),
             ))
         } else {
-            Ok(PipelineData::Value(Value::boolean(false, new_span), None))
+            Ok(PipelineData::Value(Value::bool(false, new_span), None))
         }
     } else {
-        Ok(PipelineData::Value(Value::boolean(true, new_span), None))
+        Ok(PipelineData::Value(Value::bool(true, new_span), None))
     }
 }
 
@@ -370,10 +370,10 @@ fn parse_script(
                 Vec::new(),
             ))
         } else {
-            Ok(PipelineData::Value(Value::boolean(false, span), None))
+            Ok(PipelineData::Value(Value::bool(false, span), None))
         }
     } else {
-        Ok(PipelineData::Value(Value::boolean(true, span), None))
+        Ok(PipelineData::Value(Value::bool(true, span), None))
     }
 }
 

crates/nu-engine/src/eval.rs

@@ -121,7 +121,7 @@ pub fn eval_call(
                             } else if let Some(value) = &named.default_value {
                                 callee_stack.add_var(var_id, value.to_owned());
                             } else {
-                                callee_stack.add_var(var_id, Value::boolean(true, call.head))
+                                callee_stack.add_var(var_id, Value::bool(true, call.head))
                             }
                             found = true;
                         }
@@ -133,7 +133,7 @@ pub fn eval_call(
                         } else if let Some(value) = &named.default_value {
                             callee_stack.add_var(var_id, value.to_owned());
                         } else {
-                            callee_stack.add_var(var_id, Value::boolean(true, call.head))
+                            callee_stack.add_var(var_id, Value::bool(true, call.head))
                         }
                         found = true;
                     }
@@ -141,7 +141,7 @@ pub fn eval_call(
 
                 if !found {
                     if named.arg.is_none() {
-                        callee_stack.add_var(var_id, Value::boolean(false, call.head))
+                        callee_stack.add_var(var_id, Value::bool(false, call.head))
                     } else if let Some(value) = named.default_value {
                         callee_stack.add_var(var_id, value);
                     } else {
@@ -275,7 +275,7 @@ pub fn eval_expression(
     expr: &Expression,
 ) -> Result<Value, ShellError> {
     match &expr.expr {
-        Expr::Bool(b) => Ok(Value::boolean(*b, expr.span)),
+        Expr::Bool(b) => Ok(Value::bool(*b, expr.span)),
         Expr::Int(i) => Ok(Value::int(*i, expr.span)),
         Expr::Float(f) => Ok(Value::float(*f, expr.span)),
         Expr::Binary(b) => Ok(Value::Binary {
@@ -367,7 +367,7 @@ pub fn eval_expression(
         Expr::UnaryNot(expr) => {
             let lhs = eval_expression(engine_state, stack, expr)?;
             match lhs {
-                Value::Bool { val, .. } => Ok(Value::boolean(!val, expr.span)),
+                Value::Bool { val, .. } => Ok(Value::bool(!val, expr.span)),
                 _ => Err(ShellError::TypeMismatch {
                     err_message: "bool".to_string(),
                     span: expr.span,
@@ -384,7 +384,7 @@ pub fn eval_expression(
                     match boolean {
                         Boolean::And => {
                             if lhs.is_false() {
-                                Ok(Value::boolean(false, expr.span))
+                                Ok(Value::bool(false, expr.span))
                             } else {
                                 let rhs = eval_expression(engine_state, stack, rhs)?;
                                 lhs.and(op_span, &rhs, expr.span)
@@ -392,7 +392,7 @@ pub fn eval_expression(
                         }
                         Boolean::Or => {
                             if lhs.is_true() {
-                                Ok(Value::boolean(true, expr.span))
+                                Ok(Value::bool(true, expr.span))
                             } else {
                                 let rhs = eval_expression(engine_state, stack, rhs)?;
                                 lhs.or(op_span, &rhs, expr.span)

crates/nu-engine/src/scope.rs

@@ -337,7 +337,7 @@ impl<'e, 's> ScopeData<'e, 's> {
                 Value::nothing(span),
                 Value::string("input", span),
                 Value::string(input_type.to_shape().to_string(), span),
-                Value::boolean(false, span),
+                Value::bool(false, span),
                 Value::nothing(span),
                 Value::nothing(span),
                 Value::nothing(span),
@@ -352,7 +352,7 @@ impl<'e, 's> ScopeData<'e, 's> {
                 Value::string(&req.name, span),
                 Value::string("positional", span),
                 Value::string(req.shape.to_string(), span),
-                Value::boolean(false, span),
+                Value::bool(false, span),
                 Value::nothing(span),
                 Value::string(&req.desc, span),
                 Value::string(
@@ -375,7 +375,7 @@ impl<'e, 's> ScopeData<'e, 's> {
                 Value::string(&opt.name, span),
                 Value::string("positional", span),
                 Value::string(opt.shape.to_string(), span),
-                Value::boolean(true, span),
+                Value::bool(true, span),
                 Value::nothing(span),
                 Value::string(&opt.desc, span),
                 Value::string(
@@ -402,7 +402,7 @@ impl<'e, 's> ScopeData<'e, 's> {
                 Value::string(if rest.name == "rest" { "" } else { &rest.name }, span),
                 Value::string("rest", span),
                 Value::string(rest.shape.to_string(), span),
-                Value::boolean(true, span),
+                Value::bool(true, span),
                 Value::nothing(span),
                 Value::string(&rest.desc, span),
                 Value::string(
@@ -449,7 +449,7 @@ impl<'e, 's> ScopeData<'e, 's> {
                 Value::string(&named.long, span),
                 flag_type,
                 shape,
-                Value::boolean(!named.required, span),
+                Value::bool(!named.required, span),
                 short_flag,
                 Value::string(&named.desc, span),
                 Value::string(custom_completion_command_name, span),
@@ -474,7 +474,7 @@ impl<'e, 's> ScopeData<'e, 's> {
                 Value::nothing(span),
                 Value::string("output", span),
                 Value::string(output_type.to_shape().to_string(), span),
-                Value::boolean(false, span),
+                Value::bool(false, span),
                 Value::nothing(span),
                 Value::nothing(span),
                 Value::nothing(span),

crates/nu-explore/src/commands/tweak.rs

@@ -85,8 +85,8 @@ impl SimpleCommand for TweakCmd {
 
 fn parse_value(value: &str) -> Value {
     match value {
-        "true" => Value::boolean(true, NuSpan::unknown()),
+        "true" => Value::bool(true, NuSpan::unknown()),
-        "false" => Value::boolean(false, NuSpan::unknown()),
+        "false" => Value::bool(false, NuSpan::unknown()),
         s => Value::string(s.to_owned(), NuSpan::unknown()),
     }
 }

crates/nu-explore/src/explore.rs

@@ -340,7 +340,7 @@ fn insert_bool(map: &mut HashMap<String, Value>, key: &str, value: bool) {
         return;
     }
 
-    map.insert(String::from(key), Value::boolean(value, Span::unknown()));
+    map.insert(String::from(key), Value::bool(value, Span::unknown()));
 }
 
 fn include_nu_config(config: &mut HashMap<String, Value>, style_computer: &StyleComputer) {

crates/nu-parser/src/eval.rs

@@ -12,7 +12,7 @@ pub fn eval_constant(
     expr: &Expression,
 ) -> Result<Value, ParseError> {
     match &expr.expr {
-        Expr::Bool(b) => Ok(Value::boolean(*b, expr.span)),
+        Expr::Bool(b) => Ok(Value::bool(*b, expr.span)),
         Expr::Int(i) => Ok(Value::int(*i, expr.span)),
         Expr::Float(f) => Ok(Value::float(*f, expr.span)),
         Expr::Binary(b) => Ok(Value::Binary {

crates/nu-protocol/src/config.rs

@@ -269,13 +269,13 @@ impl Value {
                 } else {
                     invalid!(Some(*$span), "should be a bool");
                     // Reconstruct
-                    $vals[$index] = Value::boolean(config.$setting, *$span);
+                    $vals[$index] = Value::bool(config.$setting, *$span);
                 }
             };
         }
         macro_rules! try_int {
             ($cols:ident, $vals:ident, $index:ident, $span:expr, $setting:ident) => {
-                if let Ok(b) = &$vals[$index].as_integer() {
+                if let Ok(b) = &$vals[$index].as_int() {
                     config.$setting = *b;
                 } else {
                     invalid!(Some(*$span), "should be an int");
@@ -350,8 +350,8 @@ impl Value {
                             vals[index] = Value::record(
                                 vec!["use_ls_colors".into(), "clickable_links".into()],
                                 vec![
-                                    Value::boolean(config.use_ls_colors, *span),
+                                    Value::bool(config.use_ls_colors, *span),
-                                    Value::boolean(config.show_clickable_links_in_ls, *span),
+                                    Value::bool(config.show_clickable_links_in_ls, *span),
                                 ],
                                 *span,
                             );
@@ -383,8 +383,8 @@ impl Value {
                             vals[index] = Value::record(
                                 vec!["use_ls_colors".into(), "clickable_links".into()],
                                 vec![
-                                    Value::boolean(config.use_ls_colors, *span),
+                                    Value::bool(config.use_ls_colors, *span),
-                                    Value::boolean(config.show_clickable_links_in_ls, *span),
+                                    Value::bool(config.show_clickable_links_in_ls, *span),
                                 ],
                                 *span,
                             );
@@ -415,7 +415,7 @@ impl Value {
                             // Reconstruct
                             vals[index] = Value::record(
                                 vec!["always_trash".into()],
-                                vec![Value::boolean(config.rm_always_trash, *span)],
+                                vec![Value::bool(config.rm_always_trash, *span)],
                                 *span,
                             );
                         }
@@ -495,10 +495,10 @@ impl Value {
                                     "isolation".into(),
                                 ],
                                 vec![
-                                    Value::boolean(config.sync_history_on_enter, *span),
+                                    Value::bool(config.sync_history_on_enter, *span),
                                     Value::int(config.max_history_size, *span),
                                     reconstruct_history_file_format!(span),
-                                    Value::boolean(config.history_isolation, *span),
+                                    Value::bool(config.history_isolation, *span),
                                 ],
                                 *span,
                             );
@@ -524,7 +524,7 @@ impl Value {
                                     vec![
                                         Value::int(config.max_external_completion_results, *$span),
                                         reconstruct_external_completer!($span),
-                                        Value::boolean(config.enable_external_completion, *$span),
+                                        Value::bool(config.enable_external_completion, *$span),
                                     ],
                                     *$span,
                                 )
@@ -662,10 +662,10 @@ impl Value {
                                     "external".into(),
                                 ],
                                 vec![
-                                    Value::boolean(config.quick_completions, *span),
+                                    Value::bool(config.quick_completions, *span),
-                                    Value::boolean(config.partial_completions, *span),
+                                    Value::bool(config.partial_completions, *span),
                                     Value::string(config.completion_algorithm.clone(), *span),
-                                    Value::boolean(config.case_sensitive_completions, *span),
+                                    Value::bool(config.case_sensitive_completions, *span),
                                     reconstruct_external!(span),
                                 ],
                                 *span,
@@ -884,7 +884,7 @@ impl Value {
                                         ],
                                         vec![
                                             Value::string("wrapping", *$span),
-                                            Value::boolean(*try_to_keep_words, *$span),
+                                            Value::bool(*try_to_keep_words, *$span),
                                         ],
                                         *$span,
                                     ),
@@ -982,7 +982,7 @@ impl Value {
                                     Value::string(config.table_mode.clone(), *span),
                                     reconstruct_index_mode!(span),
                                     reconstruct_trim_strategy!(span),
-                                    Value::boolean(config.table_show_empty, *span),
+                                    Value::bool(config.table_show_empty, *span),
                                 ],
                                 *span,
                             )
@@ -1026,7 +1026,7 @@ impl Value {
                             vals[index] = Value::record(
                                 vec!["metric".into(), "format".into()],
                                 vec![
-                                    Value::boolean(config.filesize_metric, *span),
+                                    Value::bool(config.filesize_metric, *span),
                                     Value::string(config.filesize_format.clone(), *span),
                                 ],
                                 *span,
@@ -1270,7 +1270,7 @@ impl Value {
                             vals[index] = Value::record(
                                 vec!["metric".into(), "format".into()],
                                 vec![
-                                    Value::boolean(config.filesize_metric, *span),
+                                    Value::bool(config.filesize_metric, *span),
                                     Value::string(config.filesize_format.clone(), *span),
                                 ],
                                 *span,

crates/nu-protocol/src/value/mod.rs

@@ -125,7 +125,7 @@ pub enum Value {
 impl Clone for Value {
     fn clone(&self) -> Self {
         match self {
-            Value::Bool { val, span } => Value::boolean(*val, *span),
+            Value::Bool { val, span } => Value::bool(*val, *span),
             Value::Int { val, span } => Value::int(*val, *span),
             Value::Filesize { val, span } => Value::Filesize {
                 val: *val,
@@ -193,20 +193,84 @@ impl Clone for Value {
 }
 
 impl Value {
-    pub fn as_char(&self) -> Result<char, ShellError> {
+    pub fn as_bool(&self) -> Result<bool, ShellError> {
         match self {
-            Value::String { val, span } => {
+            Value::Bool { val, .. } => Ok(*val),
-                let mut chars = val.chars();
+            x => Err(ShellError::CantConvert {
-                match (chars.next(), chars.next()) {
+                to_type: "boolean".into(),
-                    (Some(c), None) => Ok(c),
+                from_type: x.get_type().to_string(),
-                    _ => Err(ShellError::MissingParameter {
+                span: self.span()?,
-                        param_name: "single character separator".into(),
+                help: None,
-                        span: *span,
             }),
         }
     }
+
+    pub fn as_int(&self) -> Result<i64, ShellError> {
+        match self {
+            Value::Int { val, .. } => Ok(*val),
             x => Err(ShellError::CantConvert {
-                to_type: "char".into(),
+                to_type: "integer".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_float(&self) -> Result<f64, ShellError> {
+        match self {
+            Value::Float { val, .. } => Ok(*val),
+            Value::Int { val, .. } => Ok(*val as f64),
+            x => Err(ShellError::CantConvert {
+                to_type: "float".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_filesize(&self) -> Result<i64, ShellError> {
+        match self {
+            Value::Filesize { val, .. } => Ok(*val),
+            x => Err(ShellError::CantConvert {
+                to_type: "filesize".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_duration(&self) -> Result<i64, ShellError> {
+        match self {
+            Value::Duration { val, .. } => Ok(*val),
+            x => Err(ShellError::CantConvert {
+                to_type: "duration".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_date(&self) -> Result<DateTime<FixedOffset>, ShellError> {
+        match self {
+            Value::Date { val, .. } => Ok(*val),
+            x => Err(ShellError::CantConvert {
+                to_type: "date".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_range(&self) -> Result<&Range, ShellError> {
+        match self {
+            Value::Range { val, .. } => Ok(val.as_ref()),
+            x => Err(ShellError::CantConvert {
+                to_type: "range".into(),
                 from_type: x.get_type().to_string(),
                 span: self.span()?,
                 help: None,
@@ -270,6 +334,27 @@ impl Value {
         }
     }
 
+    pub fn as_char(&self) -> Result<char, ShellError> {
+        match self {
+            Value::String { val, span } => {
+                let mut chars = val.chars();
+                match (chars.next(), chars.next()) {
+                    (Some(c), None) => Ok(c),
+                    _ => Err(ShellError::MissingParameter {
+                        param_name: "single character separator".into(),
+                        span: *span,
+                    }),
+                }
+            }
+            x => Err(ShellError::CantConvert {
+                to_type: "char".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
     pub fn as_path(&self) -> Result<PathBuf, ShellError> {
         match self {
             Value::String { val, .. } => Ok(PathBuf::from(val)),
@@ -282,32 +367,6 @@ impl Value {
         }
     }
 
-    pub fn as_block(&self) -> Result<BlockId, ShellError> {
-        match self {
-            Value::Block { val, .. } => Ok(*val),
-            Value::Closure { val, .. } => Ok(*val),
-            x => Err(ShellError::CantConvert {
-                to_type: "block".into(),
-                from_type: x.get_type().to_string(),
-                span: self.span()?,
-                help: None,
-            }),
-        }
-    }
-
-    pub fn as_binary(&self) -> Result<&[u8], ShellError> {
-        match self {
-            Value::Binary { val, .. } => Ok(val),
-            Value::String { val, .. } => Ok(val.as_bytes()),
-            x => Err(ShellError::CantConvert {
-                to_type: "binary".into(),
-                from_type: x.get_type().to_string(),
-                span: self.span()?,
-                help: None,
-            }),
-        }
-    }
-
     pub fn as_record(&self) -> Result<(&[String], &[Value]), ShellError> {
         match self {
             Value::Record { cols, vals, .. } => Ok((cols, vals)),
@@ -332,11 +391,12 @@ impl Value {
         }
     }
 
-    pub fn as_bool(&self) -> Result<bool, ShellError> {
+    pub fn as_block(&self) -> Result<BlockId, ShellError> {
         match self {
-            Value::Bool { val, .. } => Ok(*val),
+            Value::Block { val, .. } => Ok(*val),
+            Value::Closure { val, .. } => Ok(*val),
             x => Err(ShellError::CantConvert {
-                to_type: "boolean".into(),
+                to_type: "block".into(),
                 from_type: x.get_type().to_string(),
                 span: self.span()?,
                 help: None,
@@ -344,12 +404,11 @@ impl Value {
         }
     }
 
-    pub fn as_float(&self) -> Result<f64, ShellError> {
+    pub fn as_closure(&self) -> Result<(BlockId, &HashMap<VarId, Value>), ShellError> {
         match self {
-            Value::Float { val, .. } => Ok(*val),
+            Value::Closure { val, captures, .. } => Ok((*val, captures)),
-            Value::Int { val, .. } => Ok(*val as f64),
             x => Err(ShellError::CantConvert {
-                to_type: "float".into(),
+                to_type: "closure".into(),
                 from_type: x.get_type().to_string(),
                 span: self.span()?,
                 help: None,
@@ -357,11 +416,60 @@ impl Value {
         }
     }
 
-    pub fn as_integer(&self) -> Result<i64, ShellError> {
+    pub fn as_binary(&self) -> Result<&[u8], ShellError> {
         match self {
-            Value::Int { val, .. } => Ok(*val),
+            Value::Binary { val, .. } => Ok(val),
+            Value::String { val, .. } => Ok(val.as_bytes()),
             x => Err(ShellError::CantConvert {
-                to_type: "integer".into(),
+                to_type: "binary".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_cell_path(&self) -> Result<&CellPath, ShellError> {
+        match self {
+            Value::CellPath { val, .. } => Ok(val),
+            x => Err(ShellError::CantConvert {
+                to_type: "cell path".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_custom_value(&self) -> Result<&dyn CustomValue, ShellError> {
+        match self {
+            Value::CustomValue { val, .. } => Ok(val.as_ref()),
+            x => Err(ShellError::CantConvert {
+                to_type: "custom value".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_lazy_record(&self) -> Result<&dyn for<'a> LazyRecord<'a>, ShellError> {
+        match self {
+            Value::LazyRecord { val, .. } => Ok(val.as_ref()),
+            x => Err(ShellError::CantConvert {
+                to_type: "lazy record".into(),
+                from_type: x.get_type().to_string(),
+                span: self.span()?,
+                help: None,
+            }),
+        }
+    }
+
+    pub fn as_match_pattern(&self) -> Result<&MatchPattern, ShellError> {
+        match self {
+            Value::MatchPattern { val, .. } => Ok(val.as_ref()),
+            x => Err(ShellError::CantConvert {
+                to_type: "match pattern".into(),
                 from_type: x.get_type().to_string(),
                 span: self.span()?,
                 help: None,
@@ -768,11 +876,6 @@ impl Value {
         matches!(self, Value::Nothing { .. })
     }
 
-    /// Create a new `Nothing` value
-    pub fn nothing(span: Span) -> Value {
-        Value::Nothing { span }
-    }
-
     /// Follow a given cell path into the value: for example accessing select elements in a stream or list
     pub fn follow_cell_path(
         self,
@@ -1635,18 +1738,8 @@ impl Value {
         }
     }
 
-    pub fn string(val: impl Into<String>, span: Span) -> Value {
+    pub fn bool(val: bool, span: Span) -> Value {
-        Value::String {
+        Value::Bool { val, span }
-            val: val.into(),
-            span,
-        }
-    }
-
-    pub fn binary(val: impl Into<Vec<u8>>, span: Span) -> Value {
-        Value::Binary {
-            val: val.into(),
-            span,
-        }
     }
 
     pub fn int(val: i64, span: Span) -> Value {
@@ -1657,8 +1750,30 @@ impl Value {
         Value::Float { val, span }
     }
 
-    pub fn boolean(val: bool, span: Span) -> Value {
+    pub fn filesize(val: i64, span: Span) -> Value {
-        Value::Bool { val, span }
+        Value::Filesize { val, span }
+    }
+
+    pub fn duration(val: i64, span: Span) -> Value {
+        Value::Duration { val, span }
+    }
+
+    pub fn date(val: DateTime<FixedOffset>, span: Span) -> Value {
+        Value::Date { val, span }
+    }
+
+    pub fn range(val: Range, span: Span) -> Value {
+        Value::Range {
+            val: Box::new(val),
+            span,
+        }
+    }
+
+    pub fn string(val: impl Into<String>, span: Span) -> Value {
+        Value::String {
+            val: val.into(),
+            span,
+        }
     }
 
     pub fn record(cols: Vec<String>, vals: Vec<Value>, span: Span) -> Value {
@@ -1679,83 +1794,165 @@ impl Value {
         Value::List { vals, span }
     }
 
-    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    pub fn block(val: BlockId, span: Span) -> Value {
-    /// when used in errors.
+        Value::Block { val, span }
-    pub fn test_string(s: impl Into<String>) -> Value {
-        Value::string(s, Span::test_data())
     }
 
-    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    pub fn closure(val: BlockId, captures: HashMap<VarId, Value>, span: Span) -> Value {
-    /// when used in errors.
+        Value::Closure {
-    pub fn test_int(val: i64) -> Value {
-        Value::Int {
             val,
-            span: Span::test_data(),
+            captures,
+            span,
         }
     }
 
-    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// Create a new `Nothing` value
-    /// when used in errors.
+    pub fn nothing(span: Span) -> Value {
-    pub fn test_float(val: f64) -> Value {
+        Value::Nothing { span }
-        Value::Float {
+    }
-            val,
+
-            span: Span::test_data(),
+    pub fn error(error: ShellError) -> Value {
+        Value::Error {
+            error: Box::new(error),
+        }
+    }
+
+    pub fn binary(val: impl Into<Vec<u8>>, span: Span) -> Value {
+        Value::Binary {
+            val: val.into(),
+            span,
+        }
+    }
+
+    pub fn cell_path(val: CellPath, span: Span) -> Value {
+        Value::CellPath { val, span }
+    }
+
+    pub fn custom_value(val: Box<dyn CustomValue>, span: Span) -> Value {
+        Value::CustomValue { val, span }
+    }
+
+    pub fn lazy_record(val: Box<dyn for<'a> LazyRecord<'a>>, span: Span) -> Value {
+        Value::LazyRecord { val, span }
+    }
+
+    pub fn match_pattern(val: MatchPattern, span: Span) -> Value {
+        Value::MatchPattern {
+            val: Box::new(val),
+            span,
         }
     }
 
     /// Note: Only use this for test data, *not* live data, as it will point into unknown source
     /// when used in errors.
     pub fn test_bool(val: bool) -> Value {
-        Value::Bool {
+        Value::bool(val, Span::test_data())
-            val,
-            span: Span::test_data(),
     }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_int(val: i64) -> Value {
+        Value::int(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_float(val: f64) -> Value {
+        Value::float(val, Span::test_data())
     }
 
     /// Note: Only use this for test data, *not* live data, as it will point into unknown source
     /// when used in errors.
     pub fn test_filesize(val: i64) -> Value {
-        Value::Filesize {
+        Value::filesize(val, Span::test_data())
-            val,
-            span: Span::test_data(),
-        }
     }
 
     /// Note: Only use this for test data, *not* live data, as it will point into unknown source
     /// when used in errors.
-    pub fn test_nothing() -> Value {
+    pub fn test_duration(val: i64) -> Value {
-        Value::Nothing {
+        Value::duration(val, Span::test_data())
-            span: Span::test_data(),
-        }
-    }
-
-    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
-    /// when used in errors.
-    pub fn test_record(cols: Vec<impl Into<String>>, vals: Vec<Value>) -> Value {
-        Value::Record {
-            cols: cols.into_iter().map(|s| s.into()).collect(),
-            vals,
-
-            span: Span::test_data(),
-        }
-    }
-
-    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
-    /// when used in errors.
-    pub fn test_list(vals: Vec<Value>) -> Value {
-        Value::List {
-            vals,
-            span: Span::test_data(),
-        }
     }
 
     /// Note: Only use this for test data, *not* live data, as it will point into unknown source
     /// when used in errors.
     pub fn test_date(val: DateTime<FixedOffset>) -> Value {
-        Value::Date {
+        Value::date(val, Span::test_data())
-            val,
-            span: Span::test_data(),
     }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_range(val: Range) -> Value {
+        Value::range(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_string(val: impl Into<String>) -> Value {
+        Value::string(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_record(cols: Vec<impl Into<String>>, vals: Vec<Value>) -> Value {
+        Value::record(
+            cols.into_iter().map(|s| s.into()).collect(),
+            vals,
+            Span::test_data(),
+        )
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_list(vals: Vec<Value>) -> Value {
+        Value::list(vals, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_block(val: BlockId) -> Value {
+        Value::block(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_closure(val: BlockId, captures: HashMap<VarId, Value>) -> Value {
+        Value::closure(val, captures, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_nothing() -> Value {
+        Value::nothing(Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_binary(val: impl Into<Vec<u8>>) -> Value {
+        Value::binary(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_cell_path(val: CellPath) -> Value {
+        Value::cell_path(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_custom_value(val: Box<dyn CustomValue>) -> Value {
+        Value::custom_value(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_lazy_record(val: Box<dyn for<'a> LazyRecord<'a>>) -> Value {
+        Value::lazy_record(val, Span::test_data())
+    }
+
+    /// Note: Only use this for test data, *not* live data, as it will point into unknown source
+    /// when used in errors.
+    pub fn test_match_pattern(val: MatchPattern) -> Value {
+        Value::match_pattern(val, Span::test_data())
     }
 }
 
@@ -3892,7 +4089,7 @@ mod tests {
                 vals: vec![
                     Value::int(0, Span::unknown()),
                     Value::float(0.0, Span::unknown()),
-                    Value::boolean(false, Span::unknown()),
+                    Value::bool(false, Span::unknown()),
                 ],
                 span: Span::unknown(),
             };

crates/nu-protocol/src/value/range.rs

@@ -105,11 +105,11 @@ impl Range {
     }
 
     pub fn from(&self) -> Result<i64, ShellError> {
-        self.from.as_integer()
+        self.from.as_int()
     }
 
     pub fn to(&self) -> Result<i64, ShellError> {
-        let to = self.to.as_integer()?;
+        let to = self.to.as_int()?;
         if self.is_end_inclusive() {
             Ok(to)
         } else {

crates/nu_plugin_query/src/query_json.rs

@@ -82,7 +82,7 @@ fn convert_gjson_value_to_nu_value(v: &gjValue, span: &Span) -> Value {
             Value::List { vals, span: *span }
         }
         gjson::Kind::Null => Value::nothing(*span),
-        gjson::Kind::False => Value::boolean(false, *span),
+        gjson::Kind::False => Value::bool(false, *span),
         gjson::Kind::Number => {
             let str_value = v.str();
             if str_value.contains('.') {
@@ -92,7 +92,7 @@ fn convert_gjson_value_to_nu_value(v: &gjValue, span: &Span) -> Value {
             }
         }
         gjson::Kind::String => Value::string(v.str(), *span),
-        gjson::Kind::True => Value::boolean(true, *span),
+        gjson::Kind::True => Value::bool(true, *span),
         gjson::Kind::Object => {
             let mut cols = vec![];
             let mut vals = vec![];

crates/nu_plugin_query/src/query_xml.rs

@@ -66,7 +66,7 @@ pub fn execute_xpath_query(
                 }
                 sxd_xpath::Value::Boolean(b) => {
                     cols.push(key.to_string());
-                    vals.push(Value::boolean(b, call.head));
+                    vals.push(Value::bool(b, call.head));
                 }
                 sxd_xpath::Value::Number(n) => {
                     cols.push(key.to_string());

src/run.rs

@@ -189,7 +189,7 @@ pub(crate) fn run_file(
     let start_time = std::time::Instant::now();
     let last_exit_code = stack.get_env_var(&*engine_state, "LAST_EXIT_CODE");
     if let Some(last_exit_code) = last_exit_code {
-        let value = last_exit_code.as_integer();
+        let value = last_exit_code.as_int();
         if let Ok(value) = value {
             if value != 0 {
                 std::process::exit(value as i32);