generate: switch the position of <initial> and <closure>, so the closure can have default parameters (#13393)

# Description
Close: #12083 
Close: #12084 

# User-Facing Changes
It's a breaking change because we have switched the position of
`<initial>` and `<closure>`, after the change, initial value will be
optional. So it's possible to do something like this:

```nushell
> let f = {|fib = [0, 1]| {out: $fib.0, next: [$fib.1, ($fib.0 + $fib.1)]} }
> generate $f | first 5
╭───┬───╮
│ 0 │ 0 │
│ 1 │ 1 │
│ 2 │ 1 │
│ 3 │ 2 │
│ 4 │ 3 │
╰───┴───╯
```

It will also raise error if user don't give initial value, and the
closure don't have default parameter.
```nushell
❯ let f = {|fib| {out: $fib.0, next: [$fib.1, ($fib.0 + $fib.1)]} }
❯ generate $f
Error:   × The initial value is missing
   ╭─[entry #5:1:1]
 1 │ generate $f
   · ────┬───
   ·     ╰── Missing intial value
   ╰────
  help: Provide <initial> value in generate, or assigning default value to closure parameter

```

# Tests + Formatting
Added some test cases.

---------

Co-authored-by: Stefan Holderbach <sholderbach@users.noreply.github.com>

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

@@ -3,7 +3,7 @@ use nu_test_support::{nu, pipeline};
 #[test]
 fn generate_no_next_break() {
     let actual = nu!(
-        "generate 1 {|x| if $x == 3 { {out: $x}} else { {out: $x, next: ($x + 1)} }} | to nuon"
+        "generate {|x| if $x == 3 { {out: $x}} else { {out: $x, next: ($x + 1)} }} 1 | to nuon"
     );
 
     assert_eq!(actual.out, "[1, 2, 3]");
@@ -11,7 +11,7 @@ fn generate_no_next_break() {
 
 #[test]
 fn generate_null_break() {
-    let actual = nu!("generate 1 {|x| if $x <= 3 { {out: $x, next: ($x + 1)} }} | to nuon");
+    let actual = nu!("generate {|x| if $x <= 3 { {out: $x, next: ($x + 1)} }} 1 | to nuon");
 
     assert_eq!(actual.out, "[1, 2, 3]");
 }
@@ -20,13 +20,13 @@ fn generate_null_break() {
 fn generate_allows_empty_output() {
     let actual = nu!(pipeline(
         r#"
-        generate 0 {|x|
+        generate {|x|
           if $x == 1 {
             {next: ($x + 1)}
           } else if $x < 3 {
             {out: $x, next: ($x + 1)}
           }
-        } | to nuon
+        } 0 | to nuon
       "#
     ));
 
@@ -37,11 +37,11 @@ fn generate_allows_empty_output() {
 fn generate_allows_no_output() {
     let actual = nu!(pipeline(
         r#"
-        generate 0 {|x|
+        generate {|x|
           if $x < 3 {
             {next: ($x + 1)}
           }
-        } | to nuon
+        } 0 | to nuon
       "#
     ));
 
@@ -52,7 +52,7 @@ fn generate_allows_no_output() {
 fn generate_allows_null_state() {
     let actual = nu!(pipeline(
         r#"
-        generate 0 {|x|
+        generate {|x|
           if $x == null {
             {out: "done"}
           } else if $x < 1 {
@@ -60,7 +60,7 @@ fn generate_allows_null_state() {
           } else {
             {out: "stopping", next: null}
           }
-        } | to nuon
+        } 0 | to nuon
       "#
     ));
 
@@ -71,7 +71,42 @@ fn generate_allows_null_state() {
 fn generate_allows_null_output() {
     let actual = nu!(pipeline(
         r#"
-        generate 0 {|x|
+        generate {|x|
+          if $x == 3 {
+            {out: "done"}
+          } else {
+            {out: null, next: ($x + 1)}
+          }
+        } 0 | to nuon
+      "#
+    ));
+
+    assert_eq!(actual.out, "[null, null, null, done]");
+}
+
+#[test]
+fn generate_disallows_extra_keys() {
+    let actual = nu!("generate {|x| {foo: bar, out: $x}} 0 ");
+    assert!(actual.err.contains("Invalid block return"));
+}
+
+#[test]
+fn generate_disallows_list() {
+    let actual = nu!("generate {|x| [$x, ($x + 1)]} 0 ");
+    assert!(actual.err.contains("Invalid block return"));
+}
+
+#[test]
+fn generate_disallows_primitive() {
+    let actual = nu!("generate {|x| 1} 0");
+    assert!(actual.err.contains("Invalid block return"));
+}
+
+#[test]
+fn generate_allow_default_parameter() {
+    let actual = nu!(pipeline(
+        r#"
+        generate {|x = 0|
           if $x == 3 {
             {out: "done"}
           } else {
@@ -82,22 +117,34 @@ fn generate_allows_null_output() {
     ));
 
     assert_eq!(actual.out, "[null, null, null, done]");
+
+    // if initial is given, use initial value
+    let actual = nu!(pipeline(
+        r#"
+        generate {|x = 0|
+          if $x == 3 {
+            {out: "done"}
+          } else {
+            {out: null, next: ($x + 1)}
+          }
+        } 1 | to nuon
+      "#
+    ));
+    assert_eq!(actual.out, "[null, null, done]");
 }
 
 #[test]
-fn generate_disallows_extra_keys() {
-    let actual = nu!("generate 0 {|x| {foo: bar, out: $x}}");
-    assert!(actual.err.contains("Invalid block return"));
-}
-
-#[test]
-fn generate_disallows_list() {
-    let actual = nu!("generate 0 {|x| [$x, ($x + 1)]}");
-    assert!(actual.err.contains("Invalid block return"));
-}
-
-#[test]
-fn generate_disallows_primitive() {
-    let actual = nu!("generate 0 {|x| 1}");
-    assert!(actual.err.contains("Invalid block return"));
+fn generate_raise_error_on_no_default_parameter_closure_and_init_val() {
+    let actual = nu!(pipeline(
+        r#"
+        generate {|x|
+          if $x == 3 {
+            {out: "done"}
+          } else {
+            {out: null, next: ($x + 1)}
+          }
+        } | to nuon
+      "#
+    ));
+    assert!(actual.err.contains("The initial value is missing"));
 }