Issue #20930 has been updated by Eregon (Benoit Daloze). With `--parser=parse.y`: ``` $ ruby --parser=parse.y -ve '[1].each { p it; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) [x86_64-linux] 1 5 $ ruby --parser=parse.y -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) [x86_64-linux] -e:1: numbered parameter is already used in -e:1: outer block here [1].each { p _1; [5].each { p _1 } } ruby: compile error (SyntaxError) ``` Which is still inconsistent between `it` and `_1`. ---------------------------------------- Bug #20930: Different semantics for nested `it` and `_1` https://bugs.ruby-lang.org/issues/20930#change-110852 * Author: Eregon (Benoit Daloze) * Status: Open * ruby -v: ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- ``` $ ruby -ve '[1].each { p it; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 $ ruby -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 1 ``` Notice the inconsistency, `it` uses the innermost block, `_1` uses the outermost block. I think `_1` semantics are slightly better, at least `_1` behaves like a normal local variable declared in the outer block then. Note that on 3.3.5 it was forbidden to nest `_1` which I think might be good for clarity/avoiding ambiguity: ``` $ ruby -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.3.5 (2024-09-03 revision ef084cc8f4) [x86_64-linux] -e:1: numbered parameter is already used in -e:1: outer block here [1].each { p _1; [5].each { p _1 } } ruby: compile error (SyntaxError) ``` --- As an aside, mixing `_1` and `it` is allowed, I think this is [good](https://bsky.app/profile/eregon.bsky.social/post/3lcg4fjcf7225), they are different things so there is not much confusion there: ``` $ ruby -ve '[1].each { p _1; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 $ ruby -ve '[1].each { p it; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 ``` -- https://bugs.ruby-lang.org/

Issue #20930 has been updated by k0kubun (Takashi Kokubun).

I think _1 semantics are slightly better, at least _1 behaves like a normal local variable declared in the outer block then.

Yeah but `_1` isn't declared in the outer block (or anywhere), so `_1` doesn't necessarily need to behave like a local variable declared in the outer block. You could also say "_1 should behave like a normal local variable declared in the inner block", and it seems as plausible as what you said.

The other problem is how to interpret it. I think Ruby master's it behavior is good. I have experienced mistakes of a name conflict issue of a local variable in a different scope, but not as often. However, just adding a read from it outside of a block only changes the meaning of inner it, which I think would increase the frequency of mistakes very much.

I agree with @mame 's opinion. When you have nested loops, you would use the iterator of the inner-most block most often. The current behavior of `it` seems to have more use cases than the one of `_1`. Ruby has prioritized solving real-world use cases over just making existing features consistent, so I don't think `it` needs to be consistent with `_1` here. ---------------------------------------- Bug #20930: Different semantics for nested `it` and `_1` https://bugs.ruby-lang.org/issues/20930#change-110861 * Author: Eregon (Benoit Daloze) * Status: Open * ruby -v: ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- ``` $ ruby -ve '[1].each { p it; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 $ ruby -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 1 ``` Notice the inconsistency, `it` uses the innermost block, `_1` uses the outermost block. I think `_1` semantics are slightly better, at least `_1` behaves like a normal local variable declared in the outer block then. Note that on 3.3.5 it was forbidden to nest `_1` which I think might be good for clarity/avoiding ambiguity: ``` $ ruby -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.3.5 (2024-09-03 revision ef084cc8f4) [x86_64-linux] -e:1: numbered parameter is already used in -e:1: outer block here [1].each { p _1; [5].each { p _1 } } ruby: compile error (SyntaxError) ``` --- As an aside, mixing `_1` and `it` is allowed, I think this is [good](https://bsky.app/profile/eregon.bsky.social/post/3lcg4fjcf7225), they are different things so there is not much confusion there: ``` $ ruby -ve '[1].each { p _1; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 $ ruby -ve '[1].each { p it; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 ``` -- https://bugs.ruby-lang.org/

Issue #20930 has been updated by k0kubun (Takashi Kokubun). Description updated Let me get this straight. parse.y was the default parser when `_1` and `it` were implemented, so Prism should have copied it. @alanwu has filed https://github.com/ruby/prism/issues/3291 for it, so let's not talk about it here. I updated your issue description to clarify what's really the problem here. As to nested `_1` being a `SyntaxError` and nested `it` being allowed, it is a conscious choice (for me) because it seems useful to be able to nest blocks like `files.map { JSON.parse(it).each { puts it } }` and it doesn't seem confusing to me. I'll put this into the dev-meeting agenda. ---------------------------------------- Bug #20930: Different semantics for nested `it` and `_1` https://bugs.ruby-lang.org/issues/20930#change-110894 * Author: Eregon (Benoit Daloze) * Status: Open * ruby -v: ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- With --parser=parse.y: ``` $ ruby --parser=parse.y -ve '[1].each { p it; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) [x86_64-linux] 1 5 $ ruby --parser=parse.y -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) [x86_64-linux] -e:1: numbered parameter is already used in -e:1: outer block here [1].each { p _1; [5].each { p _1 } } ruby: compile error (SyntaxError) ``` It is inconsistent between it and _1. --- <details> <summary>Side note about mixing `_1` and `it`, which seems good</summary> As an aside, mixing `_1` and `it` is allowed, I think this is [good](https://bsky.app/profile/eregon.bsky.social/post/3lcg4fjcf7225), they are different things so there is not much confusion there: ``` $ ruby -ve '[1].each { p _1; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 $ ruby -ve '[1].each { p it; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 ``` </details> --- <details> <summary>Prism's bug, moved to: https://github.com/ruby/prism/issues/3291</summary> ``` $ ruby -ve '[1].each { p it; [5].each { p it } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 5 $ ruby -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.4.0dev (2024-12-04T19:29:24Z master 3c91a1e5fd) +PRISM [x86_64-linux] 1 1 ``` Notice the inconsistency, `it` uses the innermost block, `_1` uses the outermost block. I think `_1` semantics are slightly better, at least `_1` behaves like a normal local variable declared in the outer block then. Note that on 3.3.5 it was forbidden to nest `_1` which I think might be good for clarity/avoiding ambiguity: ``` $ ruby -ve '[1].each { p _1; [5].each { p _1 } }' ruby 3.3.5 (2024-09-03 revision ef084cc8f4) [x86_64-linux] -e:1: numbered parameter is already used in -e:1: outer block here [1].each { p _1; [5].each { p _1 } } ruby: compile error (SyntaxError) ``` </details> -- https://bugs.ruby-lang.org/