From: daniel@...42.com
Date: 2019-12-26T22:10:35+00:00
Subject: [ruby-core:96503] [Ruby master Feature#16435] Array#to_proc

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


In all honesty, the more time goes, the less I like the various proposals that replace a block by the convert-to-proc `&` operator.

It looks to me like all the examples could be just as succintly represented with numbered parameters, with the performance advantage of not requiring intermediate Proc objects, and the cognitive advantage of not having to remember what is the behavior of `Array#to_proc`.

```ruby
data.map{_1[:name]}
data.min_by{_1[:salary]}
data.group_by{_1.dig(:department, :title)}
data.map{_1.values[0]}
data.group_by{_1.dig(:department, :title)}.values.map{_1.first[:name]}
```

Although, notice how much better it would have looked with a `_` implicit parameter and/or omitted parameter. :-) ;_;

```ruby
data.map{_[:name]}
data.min_by{_[:salary]}
data.group_by{_.dig(:department, :title)}
data.map{_.values[0]}
data.group_by{_.dig(:department, :title)}.values.map{_.first[:name]}

data.map{.dig(:name)}
data.min_by{.dig(:salary)}
data.group_by{.dig(:department, :title)}
data.map{.values[0]}
data.group_by{.dig(:department, :title)}.values.map{.first[:name]}
```


----------------------------------------
Feature #16435: Array#to_proc
https://bugs.ruby-lang.org/issues/16435#change-83435

* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
The idea is obvious, but I couldn't find it discussed anywhere on tracker before. Please point me at the previous discussions if any.

```ruby
class Array
  def to_proc
    proc { |v| v.dig(*self) }
  end
end
# Or, alternatively, see about alternatives at the end of proposal:
class Array
  def to_proc
    proc { |v| v[*self] }
  end
end

```
The implementation seems to provide clean and unambiguous collections indexing in Enumerators:
```ruby
# Basic objects data, which could be obtained from JSON, CSV, Database...
data = [
  {name: 'John', department: {id: 1, title: 'Engineering'}, salary: 1000}, 
  {name: 'Jane', department: {id: 1, title: 'Engineering'}, salary: 1200},
  {name: 'Boris', department: {id: 2, title: 'Accounting'}, salary: 800},
  {name: 'Alice', department: {id: 3, title: 'Management'}, salary: 1500}
]
data.map(&[:name])
# => ["John", "Jane", "Boris", "Alice"] 
data.min_by(&[:salary])
# => {:name=>"Boris", :department=>{:id=>2, :title=>"Accounting"}, :salary=>800} 
pp data.group_by(&[:department, :title])
# {"Engineering"=>
#   [{:name=>"John",
#     :department=>{:id=>1, :title=>"Engineering"},
#     :salary=>1000},
#    {:name=>"Jane",
#     :department=>{:id=>1, :title=>"Engineering"},
#     :salary=>1200}],
#  "Accounting"=>
#   [{:name=>"Boris",
#     :department=>{:id=>2, :title=>"Accounting"},
#     :salary=>800}],
#  "Management"=>
#   [{:name=>"Alice",
#     :department=>{:id=>3, :title=>"Management"},
#     :salary=>1500}]}

# Works with arrays, too:
data.map(&:values).map(&[0])
# => ["John", "Jane", "Boris", "Alice"]

# And with mixes:
data.group_by(&[:department, :title]).values.map(&[0, :name]) 
# => ["John", "Boris", "Alice"]
```

Naked structured data seems to be a common enough thing to make working with them easier.

Some prior info:

* Googling it around, I found the idea was first invented [back in 2014](https://thepugautomatic.com/2014/11/array-to-proc-for-hash-access/), and another one [in 2015](https://gist.github.com/geowy/39fde25ec2966f90a54b), not sure if it was proposed on the tracker.
* Other proposals for `Array#to_proc` was: to call several methods in sequence [1](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/199820), [2](https://rails.lighthouseapp.com/projects/8994/tickets/1253-arrayto_proc), and to call method with argument [1](https://www.sanityinc.com/articles/adding-array-to-proc-to-ruby/), [2](https://bugs.ruby-lang.org/issues/10829), [3](https://www.rubydoc.info/github/estum/console_utils/Array:to_proc), to call several methods in parallel: [1](https://gist.github.com/shell/1120249)

Honestly, I feel that proposed usage is the most frequently needed.

Also, the readability of the version seems more or less straightforward:

```ruby
# Existing shortcut, for example:
data.map(&:keys)
# Is equivalent to
data.map { |x| x.keys }
#          ^^^^^ -- "just remove this part"

# Proposed shortcut:
data.map(&[:name])
# Is equivalent to
data.map { |x| x[:name] }
#          ^^^^^ -- "just remove this part"
```

**`dig` or `[]` alternative implementations**

It is up to discussion (if the whole idea holds water) whether `dig` should be used or just `[]`. The `dig` version is convenient for nested structures but slightly breaks "equivalency" shown above, and just `[]` version will allow this:
```ruby
data.map(&:values).map(&[1..-1])
# => [[{:id=>1, :title=>"Engineering"}, 1000], [{:id=>1, :title=>"Engineering"}, 1200], [{:id=>2, :title=>"Accounting"}, 800], [{:id=>3, :title=>"Management"}, 1500]]
```

Maybe, for the sake of explainability, "just `[]`" should be preferred, with digging performed by other means.



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