Issue #17786 has been updated by duerst (Martin D=FCrst).


Just to be clear, I'd not be against a good way to shorten a series of `end=
`s into something simpler. But the current proposal is not at all clear on =
the exact semantics: What gets closed with an `ends`, and what doesn't get =
closed? In that sense, the `ennnnd` proposal was clearer, an `ennd` would s=
tand for two `end`s, and so on.

----------------------------------------
Feature #17786: Proposal: new  "ends" keyword
https://bugs.ruby-lang.org/issues/17786#change-91424

* Author: jzakiya (Jabari Zakiya)
* Status: Open
* Priority: Normal
----------------------------------------
I'm submitting this in the same spirit that ``endless methods`` was, to pro=
mote and produce more concise and easier to write|read code.

**Proposal**
This is a proposal to introduce a new keyword ``ends`` (or ``endall``) as a=
 terminal point to resolve the end of nested ``loops|conditionals``.

**Why**
It's a common code occurrence to have multiple levels of loops and/or condi=
tionals, which require separate ``end`` keywords to designate their
termination points. The ``end`` statements themselves are merely for syntac=
tic purposes.

It would be a benefit to programmers, and code readers, to be able to produ=
ce|read more concise code, by reducing the ``code noise`` of these
nested multiple ``end`` keywords with a shorter|cleaner syntax.

Thus, I propose creating the keyword ``ends`` as a shorter|cleaner syntax t=
o replace having to write multiple ``end`` keywords.

**Example**

Below is an example of real code which performs nested loops. With "standar=
d`` format it looks like this.

```
def render(scene, image, screenWidth, screenHeight)
  screenHeight.times do |y|
    screenWidth.times do |x|
      color =3D self.traceRay(....)
      r, g, b =3D Color.toDrawingColor(color)
      image.set(x, y, StumpyCore::RGBA.from_rgb(r, g, b))
    end =

  end =

end
```

However, from the point of view of the parser, these are all legal|equivale=
nt.

```
def render(scene, image, screenWidth, screenHeight)
  screenHeight.times do |y|
    screenWidth.times do |x|
      color =3D self.traceRay(....)
      r, g, b =3D Color.toDrawingColor(color)
      image.set(x, y, StumpyCore::RGBA.from_rgb(r, g, b))
    end     end         end     end end end
  end         end       end
end             end     end
```

This proposal would allow this type of code to be writtn as:

```
def render(scene, image, screenWidth, screenHeight)
  screenHeight.times do |y|
    screenWidth.times do |x|
      color =3D self.traceRay(....)
      r, g, b =3D Color.toDrawingColor(color)
      image.set(x, y, StumpyCore::RGBA.from_rgb(r, g, b))
ends
```
**Pros**
1) code conciseness
2) better readability
3) no whitespace dependencies
4) no conflict with legacy code
5) attractice to people coming from Python|Nim, et al

**Cons**
No technical implementation restrictions I can think of.
Maybe alternative name (endall)?

Thanks for consideration.




-- =

https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=3Dunsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>