Re: [Rails-core] [Feature] Symbol to_proc coercions: Enumerable#map can take several symbols

[Abdel Latif]

Hi,
I am new to Ruby, can you please give me an example of the orders
collection ?
Thanks.

On Wed, May 16, 2018 at 9:45 AM, Matt Jones  wrote:

>
> On May 11, 2018, at 1:10 PM, Alberto Almagro 
> wrote:
>
> These days I have been comparing records in my daily job lots of times,
> which made me think about a better way to retrieve and compare them. When I
> want to navigate through several relations in a collection I often see
> myself writing code like the following:
>
> Given orders as a collection of Order:
>
> > orders.map(&:order_option).map(&:item).map(&:title)
>
> => ['Foo', 'Bar', 'Baz']
>
>
> That is, chaining maps with Symbol to Proc coercions one after each other.
> Sharing my thoughts with my company's architect we came up with the
> alternative:
>
> > orders.map { |order| order&.order_option&.item&.title }
>
> Very small nitpick: the code above (which tolerates `nil`) isn’t
> equivalent to the chained map (which doesn’t). But anyways...
>
>
> But we agreed that the notation was awful and didn't improve what we had
> before. With this, I proposed what I think it is more like what we would
> expect Ruby to have. I would like to add a notation similar to the one we
> can find at Array#dig
>  or Hash#dig
>  in the following
> manner:
>
> > orders.map(&:order_option, &:item, &:title)
>
> The method doesn't necessarily need to be named map or collect, we can
> agree on a different name for it if you want. Please share your thoughts
> with me. If you like this, I would be very happy to write a PR to include
> it in Rails.
>
>
> This reminds me of the Elixir function `get_in` and the associated
> functions in `Elixir.Access`. I’m not sure if any of the existing methods
> would make sense to extend with the behavior, though:
>
> * `dig` is called on a collection and returns one element with many levels
> of nesting
> * `pluck` is called on a collection and returns a collection, but only at
> one level of nesting
> * the proposed function is called on a collection and returns a
> collection, with many levels of nesting
>
> Neither function can guarantee that its arguments are scalars (or even
> that they aren’t Procs, for that matter) so extending them is tricky.
> Probably better to pick a new name.
>
> You might also consider “Proc#*” from Facets:
>
> https://github.com/rubyworks/facets/blob/master/lib/core/
> facets/proc/compose.rb
>
> I haven’t tried it, but in principle this should work if the operator
> precedence goes correctly:
>
> orders.map(&:order_options * &:item * &:title)
>
> —Matt Jones
>
> --
> You received this message because you are subscribed to the Google Groups
> "Ruby on Rails: Core" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to rubyonrails-core+unsubscr...@googlegroups.com.
> To post to this group, send email to rubyonrails-core@googlegroups.com.
> Visit this group at https://groups.google.com/group/rubyonrails-core.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google Groups "Ruby 
on Rails: Core" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to rubyonrails-core+unsubscr...@googlegroups.com.
To post to this group, send email to rubyonrails-core@googlegroups.com.
Visit this group at https://groups.google.com/group/rubyonrails-core.
For more options, visit https://groups.google.com/d/optout.

Re: [Rails-core] [Feature] Symbol to_proc coercions: Enumerable#map can take several symbols

[Matt Jones]

> On May 11, 2018, at 1:10 PM, Alberto Almagro  wrote:
> 
> These days I have been comparing records in my daily job lots of times, which 
> made me think about a better way to retrieve and compare them. When I want to 
> navigate through several relations in a collection I often see myself writing 
> code like the following:
> 
> Given orders as a collection of Order:
> > orders.map(&:order_option).map(&:item).map(&:title)
> => ['Foo', 'Bar', 'Baz']
> 
> That is, chaining maps with Symbol to Proc coercions one after each other. 
> Sharing my thoughts with my company's architect we came up with the 
> alternative:
> > orders.map { |order| order&.order_option&.item&.title }
Very small nitpick: the code above (which tolerates `nil`) isn’t equivalent to 
the chained map (which doesn’t). But anyways...


> But we agreed that the notation was awful and didn't improve what we had 
> before. With this, I proposed what I think it is more like what we would 
> expect Ruby to have. I would like to add a notation similar to the one we can 
> find at Array#dig  
> or Hash#dig  in the 
> following manner:
> > orders.map(&:order_option, &:item, &:title)
> The method doesn't necessarily need to be named map or collect, we can agree 
> on a different name for it if you want. Please share your thoughts with me. 
> If you like this, I would be very happy to write a PR to include it in Rails.

This reminds me of the Elixir function `get_in` and the associated functions in 
`Elixir.Access`. I’m not sure if any of the existing methods would make sense 
to extend with the behavior, though:

* `dig` is called on a collection and returns one element with many levels of 
nesting
* `pluck` is called on a collection and returns a collection, but only at one 
level of nesting
* the proposed function is called on a collection and returns a collection, 
with many levels of nesting

Neither function can guarantee that its arguments are scalars (or even that 
they aren’t Procs, for that matter) so extending them is tricky. Probably 
better to pick a new name.

You might also consider “Proc#*” from Facets:

https://github.com/rubyworks/facets/blob/master/lib/core/facets/proc/compose.rb

I haven’t tried it, but in principle this should work if the operator 
precedence goes correctly:

orders.map(&:order_options * &:item * &:title)

—Matt Jones

-- 
You received this message because you are subscribed to the Google Groups "Ruby 
on Rails: Core" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to rubyonrails-core+unsubscr...@googlegroups.com.
To post to this group, send email to rubyonrails-core@googlegroups.com.
Visit this group at https://groups.google.com/group/rubyonrails-core.
For more options, visit https://groups.google.com/d/optout.