[ruby-core:106913] [Ruby master Feature#18402] Argument Labels

Issue #18402 has been updated by janosch-x (Janosch Müller).


i really like this in Swift so i'll try to give another example for how this addition might improve both readability and conciseness.

currently there are two approaches: using verbose names for keyword arguments or short ones. both have disadvantages that could be overcome with the proposed feature.

**current approach 1: spelling it all out**

this makes both the invocation as well as the body of the method verbose, and can make them grammatically weird or misleading to read.

```ruby
def extract_bad_records(from_relation:)
  # lots of code referring to `from_relation`, e.g.
  # from_relation.select do ...
end
```

**current approach 2: keeping it short**

this makes the method nice to use, but makes it hard to read the method body itself.

```ruby
def extract_bad_records(from:)
  # lots of code referring to `from`, e.g. 
  # from.select do ...
end
```

**with labelled arguments**

makes the method nice to use AND read.

```ruby
def extract_bad_records(from => relation:)
  # lots of code referring to relation, e.g.
  # relation.select do ...
end
```

of course this example is a bit artificial as one would usually make a single or primary argument a positional argument instead of a kwarg, but you get the idea.

----------------------------------------
Feature #18402: Argument Labels
https://bugs.ruby-lang.org/issues/18402#change-95733

* Author: Lomig (Lomig Enfroy)
* Status: Open
* Priority: Normal
----------------------------------------
As a developer, I mainly program in two languages: Swift and Ruby.

I love Ruby with all my heart, but I came to like a particular feature of Swift: **Argument labels** ; I would love to see them appear in Ruby.
Matz on Twitter suggested I post a feature request, so here we are!


# Context
Naming is hard.
Keyword arguments helps defining methods that are readable and allow for flexibility ordering arguments, but the result may be a little too verbose as I use to create methods like:

``` ruby
def change_color_for_user_until_date(new_color:, user:, end_date:)
  do_something_with(new_color)
  do_something_else_with(user, end_date)
end

change_color_for_user_until_date(new_color: :blue, user: user, end_date: DateTime.tomorrow)
```

Also, that's not as readable in a "natural way" as plenty of code we can produce with Ruby.

Copying Swift, I would love to have argument labels, aka the option to define a different name for the argument and its related parameter.



# Right now

This code is a no-go, as it would be a nightmare to maintain:
(the code below is using reserved keywords so would not work in reality, but it's for the sake of clarity and the sake of the example)


```ruby
def change_color(to:, for:, until:)
  new_color, user, end_date = to, for, until

  do_something_with(to)
  do_something_else_with(for, until)  # What does this do with which data again?
end

change_color(to: :blue, for: user, until: DateTime.tomorrow)
```

This being said, I can simulate such a behaviour this way:
(the code below is using reserved keywords so would not work in reality, but it's for the sake of clarity and the sake of the example)

```ruby
def change_color(to:, for:, until:)
  new_color, user, end_date = to, for, until # well, those are reserved keywords, I would never be able to use them like that

  do_something_with(new_color)
  do_something_else_with(user, end_date)
end

change_color(to: :blue, for: user, until: DateTime.tomorrow)
```

That's not perfect though:
* Not standardized enough
* Conflict with reserved keywords (in reality, I would try to find synonyms? `change_color(with: :blue, regarding: user, up_until: DateTime.tomorrow)` ?)
* An extra line, and not so elegant

# The feature request mirroring Swift
It does not have to be implemented exactly this way, of course!

```ruby
def change_color(to new_color:, for user:, until end_date:)

  do_something_with(new_color)
  do_something_else_with(user, end_date) # No use of reserved keywords anymore, and readable variable name!
end

change_color(to: :blue, for: user, until: DateTime.tomorrow)

```

Thanks in advance for your insight on this matter,
Cheers!



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

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