Numbered each (#2100)

* Add --numbered to each

* Fix example tester and add numbered each

crates/nu-cli/src/commands/compact.rs

@@ -40,7 +40,7 @@ impl WholeStreamCommand for Compact {
         vec![
             Example {
                 description: "Filter out all null entries in a list",
-                example: "echo [1 2 $null 3 $null $null] | compact target",
+                example: "echo [1 2 $null 3 $null $null] | compact",
                 result: Some(vec![
                     UntaggedValue::int(1).into(),
                     UntaggedValue::int(2).into(),

crates/nu-cli/src/commands/each.rs

@@ -7,14 +7,16 @@ use futures::stream::once;
 use nu_errors::ShellError;
 use nu_protocol::{
     hir::Block, hir::Expression, hir::SpannedExpression, hir::Synthetic, Scope, Signature,
-    SyntaxShape, UntaggedValue, Value,
+    SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
 };
+use nu_source::Tagged;
 
 pub struct Each;
 
 #[derive(Deserialize)]
 pub struct EachArgs {
     block: Block,
+    numbered: Tagged<bool>,
 }
 
 #[async_trait]
@@ -24,11 +26,13 @@ impl WholeStreamCommand for Each {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("each").required(
-            "block",
-            SyntaxShape::Block,
-            "the block to run on each row",
-        )
+        Signature::build("each")
+            .required("block", SyntaxShape::Block, "the block to run on each row")
+            .switch(
+                "numbered",
+                "returned a numbered item ($it.index and $it.item)",
+                Some('n'),
+            )
     }
 
     fn usage(&self) -> &str {
@@ -45,6 +49,11 @@ impl WholeStreamCommand for Each {
 
     fn examples(&self) -> Vec<Example> {
         vec![
+            Example {
+                description: "Echo the sum of each row",
+                example: "echo [[1 2] [3 4]] | each { echo $it | math sum }",
+                result: None,
+            },
             Example {
                 description: "Echo the square of each integer",
                 example: "echo [1 2 3] | each { echo $(= $it * $it) }",
@@ -55,12 +64,10 @@ impl WholeStreamCommand for Each {
                 ]),
             },
             Example {
-                description: "Echo the sum of each row",
-                example: "echo [[1 2] [3 4]] | each { echo $it | math sum }",
-                result: Some(vec![
-                    UntaggedValue::int(3).into(),
-                    UntaggedValue::int(7).into(),
-                ]),
+                description: "Number each item and echo a message",
+                example:
+                    "echo ['bob' 'fred'] | each --numbered { echo `{{$it.index}} is {{$it.item}}` }",
+                result: Some(vec![Value::from("0 is bob"), Value::from("1 is fred")]),
             },
         ]
     }
@@ -111,21 +118,47 @@ async fn each(
     let context = Arc::new(Context::from_raw(&raw_args, &registry));
     let (each_args, input): (EachArgs, _) = raw_args.process(&registry).await?;
     let block = Arc::new(each_args.block);
-    Ok(input
-        .then(move |input| {
-            let block = block.clone();
-            let scope = scope.clone();
-            let head = head.clone();
-            let context = context.clone();
-            async {
-                match process_row(block, scope, head, context, input).await {
-                    Ok(s) => s,
-                    Err(e) => OutputStream::one(Err(e)),
+
+    if each_args.numbered.item {
+        Ok(input
+            .enumerate()
+            .then(move |input| {
+                let block = block.clone();
+                let scope = scope.clone();
+                let head = head.clone();
+                let context = context.clone();
+
+                let mut dict = TaggedDictBuilder::new(input.1.tag());
+                dict.insert_untagged("index", UntaggedValue::int(input.0));
+                dict.insert_value("item", input.1);
+
+                async {
+                    match process_row(block, scope, head, context, dict.into_value()).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
                 }
-            }
-        })
-        .flatten()
-        .to_output_stream())
+            })
+            .flatten()
+            .to_output_stream())
+    } else {
+        Ok(input
+            .then(move |input| {
+                let block = block.clone();
+                let scope = scope.clone();
+                let head = head.clone();
+                let context = context.clone();
+
+                async {
+                    match process_row(block, scope, head, context, input).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream())
+    }
 }
 
 #[cfg(test)]