From: "Lomig (Lomig Enfroy)" <noreply@...>
Date: 2021-12-20T21:08:14+00:00
Subject: [ruby-core:106751] [Ruby master Feature#18402] Argument Labels

Issue #18402 has been updated by Lomig (Lomig Enfroy).



duerst (Martin D��rst) wrote in #note-6:
> Does this mean that both names can be used inside the method? And in that case, would they alias the same variable, or would there be two variables? Or can only one of the names be used inside the method, and only the other outside?

The outer name is the only one we can use externally, and the inner name the only one we can use inside the method, and they represent the exact same data.


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

* 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:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>