Add lazy closure evaluation to default (#14160) (#15654)

# Description

This PR adds lazy closure evaluation to the `default` command (closes
#14160).

- For non-closure values and without providing a column name, `default`
acts the same as before
- The user can now provide multiple column names to populate if empty
- If the user provides a column name, the input must be a record or
list, otherwise an error is created.
- The user can now provide a closure as a default value
  - This closure is run without any arguments or input
  - The closure is never evaluated if the value isn't needed
- Even when column names are supplied, the closure is only run once (and
cached to prevent re-calling it)

For example:

```nushell
> default { 1 + 2 } # => 3
> null | default 3 a   # => previously `null`, now errors
> 1 | default { sleep 5sec; 3 } # => `1`, without waiting 5 seconds

> let optional_var = null; $optional_var | default { input 'Enter value: ' } # => Returns user input
> 5 | default { input 'Enter value: ' } # => `5`, without prompting user

> ls | default { sleep 5sec; 'N/A' } name # => No-op since `name` column is never empty
> ls | default { sleep 5sec; 'N/A' } foo bar # => creates columns `foo` and `bar`; only takes 5 seconds since closure result is cached

# Old behavior is the same
> [] | default 'foo' # => []
> [] | default --empty 'foo' # => 'foo'
> default 5 # => 5
```

# User-Facing Changes

- Users can add default values to multiple columns now.
- Users can now use closures as the default value passed to `default`.
- To return a closure, the user must wrap the closure they want to
return inside another closure, which will be run (`default { $my_closure
}`).

# Tests + Formatting

All tests pass.

# After Submitting

---------

Co-authored-by: 132ikl <132@ikl.sh>

crates/nu-command/tests/commands/default.rs

@@ -150,3 +150,97 @@ fn do_not_replace_non_empty_list_stream() {
         assert_eq!(actual.out, "2");
     })
 }
+
+#[test]
+fn closure_eval_simple() {
+    let actual = nu!(r#"null | default { 1 }"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn closure_eval_complex() {
+    let actual = nu!(r#"null | default { seq 1 5 | math sum }"#);
+    assert_eq!(actual.out, "15");
+}
+
+#[test]
+fn closure_eval_is_lazy() {
+    let actual = nu!(r#"1 | default { error make -u {msg: foo} }"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn column_closure_eval_is_lazy() {
+    let actual = nu!(r#"{a: 1} | default { error make -u {msg: foo} } a | get a"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn closure_eval_replace_empty_string() {
+    let actual = nu!(r#"'' | default --empty { 1 }"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn closure_eval_do_not_replace_empty_string() {
+    let actual = nu!(r#"'' | default { 1 }"#);
+    assert_eq!(actual.out, "");
+}
+
+#[test]
+fn closure_eval_replace_empty_list() {
+    let actual = nu!(r#"[] | default --empty { 1 }"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn closure_eval_do_not_replace_empty_list() {
+    let actual = nu!(r#"[] | default { 1 } | length"#);
+    assert_eq!(actual.out, "0");
+}
+
+#[test]
+fn closure_eval_replace_empty_record() {
+    let actual = nu!(r#"{} | default --empty { 1 }"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn closure_eval_do_not_replace_empty_record() {
+    let actual = nu!(r#"{} | default { 1 } | columns | length"#);
+    assert_eq!(actual.out, "0");
+}
+
+#[test]
+fn closure_eval_add_missing_column_record() {
+    let actual = nu!(r#"
+        {a: 1} | default { 2 } b | get b
+    "#);
+    assert_eq!(actual.out, "2");
+}
+
+#[test]
+fn closure_eval_add_missing_column_table() {
+    let actual = nu!(r#"
+        [{a: 1, b: 2}, {b: 4}] | default { 3 } a | get a | to json -r
+    "#);
+    assert_eq!(actual.out, "[1,3]");
+}
+
+#[test]
+fn closure_eval_replace_empty_column() {
+    let actual = nu!(r#"{a: ''} | default -e { 1 } a | get a"#);
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn replace_multiple_columns() {
+    let actual = nu!(r#"{a: ''} | default -e 1 a b | values | to json -r"#);
+    assert_eq!(actual.out, "[1,1]");
+}
+
+#[test]
+fn return_closure_value() {
+    let actual = nu!(r#"null | default { {||} }"#);
+    assert!(actual.out.starts_with("closure"));
+}