[ruby-core:95494] [Ruby master Feature#16273] Proposal: Shorthand operator for "#instance_method"

[zverok.offline@gmail.com]

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


Funnily enough (and not completely intentionally) the problem is "solved" with #16264:

```ruby
.:zip.call(*arrays)
# or even... for those who likes to cry "code golf!"
.:zip.(*arrays)
```
Currently, you also can
```ruby
:zip.to_proc.call(*arrays)
```

Though, I tend to agree with @mrkn that "no-tricks" first example looks pretty clear... But I understand that in codebase where this metaphor emerges regularly, it could become tiresome and too non-atomic to read.

One another non-orthodox suggestion (which uses `#then` loathed by some, but of all the rest of examples the only one which reads directly "zip first array with the rest of them"):
```ruby
arrays.then { |first, *rest| first.zip(*rest) }
```

----------------------------------------
Feature #16273: Proposal: Shorthand operator for "#instance_method"
https://bugs.ruby-lang.org/issues/16273#change-82265

* Author: osyo (manga osyo)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
hi, created issues to discuss shorthand for "#instance_method"

## Overview

Ruby 2.7 adds a `#method` shorthand `.:` operator.

* [Feature #12125: Proposal: Shorthand operator for Object#method - Ruby master - Ruby Issue Tracking System](https://bugs.ruby-lang.org/issues/12125)
* [Feature #13581: Syntax sugar for method reference - CommonRuby - Ruby Issue Tracking System](https://bugs.ruby-lang.org/issues/13581)

In this issues want to discuss the shorthand operator for "#instance_method".


## Background

If you want to pass an array to `Array#zip` or `Hash#merge` as shown below, the code will be messy.

```ruby
arrays = [["a", "b"], ["c"], ["d", "e"]]
hashs  = [{"a" => 1}, {"b" => 2, "c" => 3}, {"d" => 4, "e" => 5}]

# `#first` must be a receiver and the value excluding `#first` must be passed as an argument
arrays.first.zip(*arrays.drop(1))
arrays.first.product(*arrays.drop(1))
hashs.first.merge(*hashs.drop(1))
```

This can be solved by using `# bind_call` ([# 15955] (https://bugs.ruby-lang.org/issues/15955)).

```ruby
arrays = [["a", "b"], ["c"], ["d", "e"]]
hashs  = [{"a" => 1}, {"b" => 2, "c" => 3}, {"d" => 4, "e" => 5}]

Array.instance_method(:zip).bind_call(*arrays)
Array.instance_method(:product).bind_call(*arrays)
Hash.instance_method(:merge).bind_call(*hashs)
```

But `#instance_method` is long.
I'm thinking shorthand operator for `#instance_method`.

:MEMO: There was a suggestion to add `Array.zip` or `Array.product` in the past

* [Feature #8970: Array.zip and Array.product - Ruby master - Ruby Issue Tracking System](https://bugs.ruby-lang.org/issues/8970)
* [Feature #6499: Array::zip - Ruby master - Ruby Issue Tracking System](https://bugs.ruby-lang.org/issues/6499)
* [Feature #7444: Array#product_set - Ruby master - Ruby Issue Tracking System](https://bugs.ruby-lang.org/issues/7444)

## Proposal new operator

I can't come up with a suitable operator yet, sorry...
However, considering the `.:` operator, I think "operator + Symbol (`:`)" is good.

```ruby
# Document-like writing
# `#` + operator
Array#zip
Array.#zip
Array#:zip

# Constant-link writing
# :: + :hoge
Array:::zip
Array::#zip
```

Also, the following syntax is valid at this time, so it may be difficult to adopt.

```ruby
Array!zip
Array@zip
Array&zip
Array:zip
```

Please comment if you are interested in the shorthand operator for `# instance_method`.

* Other `#instance_method` usecase
* Proposal shorthand operator
* etc...

Thank you! :)




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