Issue #16460 has been updated by Dan0042 (Daniel DeLorme).


It's a nice idea, and I rather like the original syntax proposed for its high readability, even though it would require adjusting our expectations. It's very different from usual ruby but since it's in the very limited context of a parameter list that may be acceptable.

But it's worth pointing out that Matz has been rather conservative when it comes to method parameters. A syntax like `foo(@x)` that would allow direct assignment to instance variables has already been rejected.


----------------------------------------
Feature #16460: External names for keyword parameters in method definitions
https://bugs.ruby-lang.org/issues/16460#change-83564

* Author: harrisonb (Harrison Bachrach)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Hello! This is my first time filing an issue and I was unable to find anything similar. I apologize if one already exists.

In other languages (such as JavaScript, Swift, and Crystal), it is possible to have two names for a given keyword argument: one that is used in method invocation, and one used in the method definition. Here is an example from Crystal (which has syntax very similar to Ruby):

```crystal
def increment(value, by amount)
  value + amount
end

increment(value: 5, by: 10)
```

This helps create more readable method invocations and definitions. It would be especially helpful in Ruby as the language lacks a destructuring syntax for hashes/keyword args. This is unlike JavaScript, where you can do something like:

```javascript
const { nameOfOneProperty: newNameForTheProperty, nameOfAnotherProperty: newNameForTheOtherProperty } = foo;
```

where `foo` is a JavaScript Object that has the properties `nameOfOneProperty` or `nameOfAnotherProperty` (If it did not have either of them, the corresponding identifiers (newNameForTheProperty and newNameForTheOtherProperty would be initialized to undefined).

I'm thinking that such a change would pair nicely with the new 3.0 keyword argument changes.

Others have suggested that this could also be helpful if the keyword params collide with reserved keywords in Ruby, e.g.:

```ruby
def reserve_appointment(when:)
  Appointment.create(time: when) #=> SyntaxError: unexpected `when', expecting `end'
end
```

Currently, one must use `local_variable_get` to get around this issue, e.g.:

```ruby
def reserve_appointment(when:)
  time = local_variable_get(:when)
  Appointment.create(time: time)
end
```

---

## Syntax options:

1. No arrow syntax (original proposal)
```ruby
def name(external_name internal_name: default_value)
  # ...
end
# Example
def move(from source: 'src/', to destination: 'dist/', at time:)
  # ...
end
```

1. Infix arrow syntax
```ruby
def name(external_name => internal_name: default_value)
  # ...
end
# Example
def move(from => source: 'src/', to => destination: 'dist/', at => time:)
  # ...
end
```

1. Postfix arrow syntax (suggested by zverok (Victor Shepelev))
```ruby
def name(external_name: default_value => internal_name)
  # ...
end
# Example
def move(from: 'src/' => source, to: 'dist/' => destination, at: => time)
  # ...
end
```



-- 
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>