Allow let to be able to be used at the end of the pipeline (#17247)

Fun change here. This PR allows the `let` command to be used at the end
of a pipeline.

<img width="2316" height="1538" alt="image"
src="https://github.com/user-attachments/assets/8acf9a8e-79c1-4be8-8fb6-93966f671fc4"
/>

Disallow infinite ranges when used with `let` at the end of the pipeline
<img width="1911" height="1203" alt="image"
src="https://github.com/user-attachments/assets/dfed053c-8b5c-476c-9b09-c3df3ca7dc38"
/>

Related #16404, #11951

## Release notes summary - What our users need to know
The `let` command is now allowed to be at the end of the pipeline when a
variable name is also provided.
```nushell
ls | get name | let files
```

## Tasks after submitting
<!-- Remove any tasks which aren't relevant for your PR, or add your own
-->
- [ ] Update the
[documentation](https://github.com/nushell/nushell.github.io)

Author: fdncred

crates/nu-cmd-lang/src/core_commands/let_.rs

@@ -18,7 +18,7 @@ impl Command for Let {
             .input_output_types(vec![(Type::Any, Type::Nothing)])
             .allow_variants_without_examples(true)
             .required("var_name", SyntaxShape::VarWithOptType, "Variable name.")
-            .required(
+            .optional(
                 "initial_value",
                 SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::MathExpression)),
                 "Equals sign followed by value.",
@@ -71,6 +71,11 @@ impl Command for Let {
                 example: "let x = if false { -1 } else { 1 }",
                 result: None,
             },
+            Example {
+                description: "Set a variable to the output of a pipeline",
+                example: "ls | let files",
+                result: None,
+            },
         ]
     }
 }

crates/nu-engine/src/compile/keyword.rs

@@ -297,30 +297,36 @@ pub(crate) fn compile_let(
 ) -> Result<(), CompileError> {
     // Pseudocode:
     //
-    // %io_reg <- ...<block>... <- %io_reg
+    // %io_reg <- ...<block>... <- %io_reg  (if block provided)
     // store-variable $var, %io_reg
     let invalid = || CompileError::InvalidKeywordCall {
         keyword: "let".into(),
         span: call.head,
     };
 
     let var_decl_arg = call.positional_nth(0).ok_or_else(invalid)?;
-    let block_arg = call.positional_nth(1).ok_or_else(invalid)?;
-
     let var_id = var_decl_arg.as_var().ok_or_else(invalid)?;
-    let block_id = block_arg.as_block().ok_or_else(invalid)?;
-    let block = working_set.get_block(block_id);
 
-    let variable = working_set.get_variable(var_id);
+    // Handle the optional initial_value (expression after =)
+    // Two cases:
+    // 1. `let var = expr`: compile the expr block and store its result
+    // 2. `let var` (at end of pipeline): use the pipeline input directly
+    if let Some(block_arg) = call.positional_nth(1) {
+        let block_id = block_arg.as_block().ok_or_else(invalid)?;
+        let block = working_set.get_block(block_id);
 
-    compile_block(
-        working_set,
-        builder,
-        block,
-        RedirectModes::value(call.head),
-        Some(io_reg),
-        io_reg,
-    )?;
+        compile_block(
+            working_set,
+            builder,
+            block,
+            RedirectModes::value(call.head),
+            Some(io_reg),
+            io_reg,
+        )?;
+    }
+    // If no initial_value provided, io_reg already contains the pipeline input to assign
+
+    let variable = working_set.get_variable(var_id);
 
     // If the variable is a glob type variable, we should cast it with GlobFrom
     if variable.ty == Type::Glob {

crates/nu-parser/src/parser.rs

@@ -6051,7 +6051,7 @@ pub fn parse_expression(working_set: &mut StateWorkingSet, spans: &[Span]) -> Ex
 
                 parse_call(working_set, &spans[pos..], spans[0])
             }
-            b"let" | b"const" | b"mut" => {
+            b"const" | b"mut" => {
                 working_set.error(ParseError::AssignInPipeline(
                     String::from_utf8(bytes)
                         .expect("builtin commands bytes should be able to convert to string"),

crates/nu-parser/tests/test_parser.rs

@@ -3169,3 +3169,33 @@ mod record {
         assert_ne!(op.span, rhs.span)
     }
 }
+
+#[test]
+fn parse_let_in_pipeline() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    // This should parse without errors
+    let block = parse(&mut working_set, None, b"ls | let files", true);
+
+    assert!(
+        working_set.parse_errors.is_empty(),
+        "Parse errors: {:?}",
+        working_set.parse_errors
+    );
+
+    // Check that we have a pipeline with two elements
+    assert_eq!(block.pipelines.len(), 1);
+    let pipeline = &block.pipelines[0];
+    assert_eq!(pipeline.elements.len(), 2);
+
+    // Both elements should be external calls since ls and let are not declared
+    assert!(matches!(
+        pipeline.elements[0].expr.expr,
+        Expr::ExternalCall(_, _)
+    ));
+    assert!(matches!(
+        pipeline.elements[1].expr.expr,
+        Expr::ExternalCall(_, _)
+    ));
+}