[ruby-core:116006] [Ruby master Feature#20054] Replace the use of `def` in endless method definitions with a new sigil

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





What about using '&', i.e. resulting in `&foo =3D method_body`? '&' is defi=
nitely associated with methods/blocks/procs, both in the parameter list of =
a method definition and in the `&:method_name` idiom.=20



----------------------------------------

Feature #20054: Replace the use of `def` in endless method definitions with=
 a new sigil

https://bugs.ruby-lang.org/issues/20054#change-106000



* Author: sawa (Tsuyoshi Sawada)

* Status: Rejected

* Priority: Normal

----------------------------------------

I propose to remove the use of keyword `def` from the syntax of endless met=
hod definition, and introduce a new sigil instead of it. There are several =
possibilities for what character to use as the sigil, but the most seemingl=
y promising one to me at this point is the colon. So, instead of:



```rb

def foo =3D method_body

```



I propose to write



```rb

:foo =3D method_body

```



There a few reasons to dispense with `def` in endless method definition.



First, the current syntax for endless method definition looks too similar t=
o conventional method definition. Without endless method definition, we cou=
ld already define a method in a single line:



```rb

def foo; method_body end

```



and compared to this, what the endless method definition does is that, it o=
nly saves you from typing the `end` keyword just by replacing the semicolon=
 with an equal sign. This actually had not made much sense to me. Just savi=
ng you from typing the keyword `end` looks too small of a change for introd=
ucing new syntax. In order for endless method definition syntax to be justi=
fied (as a shorthand for conventional method definition), it needs to save =
more typing.



Second, in #19392, some people are claiming to change the precedence involv=
ing endless method definition. I agree with Matz and other developers who s=
upport the current precedence in which:



```rb

def foo =3D bar and baz

```



is interpreted as:



```rb

(def foo =3D bar) and baz

```



and I understand that the controversy is due to the look and feel of the ke=
yword `def`. `def` has lower precedence than `and` in conventional method d=
efinition, although `=3D` has higher precedence than `and` in variable/cons=
tant assignment. Mixing the low-precedence `def` and the high-precedence `=
=3D` into a single syntax was the cause of the trouble, according to my opi=
nion.



Thence, we should get rid of `def`. Once we do so, we need to distinguish e=
ndless method definition from variable/constant assignment in a new way. Wh=
at came to my mind was to use a single character: a sigil.



Especially, using the colon seems to make sense to me for several reasons:



Most importantly, assignment to a symbol is impossible, and it currently ra=
ises a syntax error, so it would not conflict with variable/constant assign=
ment syntax.



Within Ruby syntax, symbol is naturally used to represent a method name. Fo=
r example, in `foo(&:bar)` constructions, users are used to passing a metho=
d name as a symbol. Also, a method definition returns a symbol representing=
 the method name. So, making the endless method definition syntax look supe=
rficially like an "assignment to a symbol" would make sense.







--=20

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

 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-c=
ore.ml.ruby-lang.org/