Issue #16746 has been updated by zverok (Victor Shepelev).


To add an "opinion perspective"... I, for one, even if not fascinated but at least intrigued by new syntax.

My reasoning is as follows:

* The most precious Ruby's quality for me is "expressiveness at the level of the single 'phrase' (expression)", and it is not "code golf"-expressiveness, but rather structuring language's consistency around the idea of building phrases with all related senses packed, while staying lucid about the intention (I believe that, as our "TIMTOWTDI" is opposite to Python's "there should be one obvious way...", this quality is also opposite to Pythons "sparse is better than dense")
* (I am fully aware that nowadays I am in a minority with this viewpoint: whenever the similar discussions are raised, I _see_ a huge difference between "it can be stated in one phrase" vs "it can not", while most of my correspondents find it negligible)
* I believe that the difference of "how you write it when there is one statement" vs "...more than one statement" is intentional, and fruitful: "just add one more line to 10-line method" typically small addition, but "just add one more line to 1-line method" frequently makes one think: may be that's not what you really need to do, maybe data flow becomes unclear? One existing example:

```ruby
collection.map { |x| do_something_with(x) } # one line! cool!
# ...what if I want to calculate several other values on the way? I NEED to restructure it:
collection.map do |x|
  log_processing(x)
  total += x
  do_something_with(x)
end
# ...which MIGHT imply that "I am doing something wrong", and maybe what would clearer express intent
# is separating calculation of total, and move `log_processing` inside `do_something`
```
* So, it was actually always felt for me as "a bit too wordy" for trivial/short methods to write it as

```ruby
def some_method(foo)
  foo.bar(baz).then { |result| result + 3 }
end
```
* ...alongside with "nicer formatting" of empty lines between methods, and probably requirement to document every method, and whatnot, it means that extraction of trivial utility method feels like "making MORE code than necessary", so I'd really try how it would feel with

```ruby
def just_utility(foo)= foo.bar(baz).then { |result| result + 3 }
def other_utility(foo)= "<#{self}(#{foo})>"
def third_utility(foo)= log.print(nicely_formatted(foo))
```
* ...and I believe that "what if you need to add second statement, you will reformat the code completely?" is a good thing, not bad: you'll think twice before adding to "simple utility one-statement" method something that really, actually, maybe not belongs there.

----------------------------------------
Feature #16746: Endless method definition
https://bugs.ruby-lang.org/issues/16746#change-86332

* Author: mame (Yusuke Endoh)
* Status: Closed
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
----------------------------------------
Ruby syntax is full of "end"s.  I'm paranoid that the ends end Ruby.  I hope Ruby is endless.

So, I'd like to propose a new method definition syntax.

```ruby
def: value(args) = expression
```

As you see, there is no "end".

Examples.

```ruby
def: hello(name) =
  puts("Hello, #{ name }")

hello("endless Ruby") #=> Hello, endless Ruby
```

```ruby
def: inc(x) = x + 1

p inc(42) #=> 43
```

```ruby
x = Object.new

def: x.foo = "FOO"

p x.foo #=> "FOO"
```

```ruby
def: fib(x) =
  x < 2 ? x : fib(x-1) + fib(x-2)

p fib(10) #=> 55
```

Limitations.

* `def: foo x = x` is invalid; the parentheses for formal arguments are mandatory.
* `private def: foo = x` is invalid; this method definition cannot be an method argument.

A patch is attached.  No conflicts.

---Files--------------------------------
endless-method-definition.patch (2.47 KB)


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

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