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 <al2o...@gmail.com> wrote:
>
> On May 11, 2018, at 1:10 PM, Alberto Almagro <albertoalma...@gmail.com>
> 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
> <https://ruby-doc.org/core-2.5.0/Array.html#method-i-dig> or Hash#dig
> <https://ruby-doc.org/core-2.5.0/Hash.html#method-i-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.
