Re: tap { break } idiom deserves its own Kernel method?

On Mon, Jul 22, 2013 at 7:37 PM, Andy Lowry <[e-mail]> wrote:

> I use this idiom from time to time:
>
>   x = expr.tap{|value| break expr-involving-value)}
>
> It works well, but reading it requires the reader to understand a
> relatively obscure part of ruby, namely the behavior of break during a
> yield.
>
> Here's my most recent case where the idiom useful: I've got a list of
> model object ids, and I want produce an array of the model objects in
> the order their ids appear in that list.
>
> Obviously, this works:
>
>    id_list.map{|id| Model.find(id)}
>
> Here's an approach that does a single query:
>
>    unsorted = Model.where(id: id_list)
>    objs_map = unsorted.reduce(Hash.new) {|h,o| h[o.id] = o; h}
>    sorted = id_list.map{|id| objs_map[id]}
>
> Here's the same thing using tap/break, to make it more obvious that the
> only thing I'm really interested in is that final value "sorted":
>
>    sorted = Model.where(id: id_list).tap do |unsorted|
>      break unsorted.reduce(Hash.new) {|h,o| h[o.id] = o; h}
>    end.tap do |objs_hash|
>      break id_list.map{|id| objs_hash[id]}
>    end
>
> I find enough uses for this idiom that I'm thinking it'd be worth giving
> it a name and its own Kernel method, rather than forcing the use of a
> relatively narrowly understood language feature (behavior of break
> during yield). "pipe" or "transform" may be a good name for it.
> Definition would be almost identical to that of tap.
>
>   Kernel.module_eval do
>     def pipe
>       yield self
>     end
>   end
>
> Then the example above turns into:
>
>   sorted = Model.where(id: id_list).pipe do |unsorted|
>     unsorted.reduce(Hash.new) {|h,o| h[o.id] = o; h}
>   end.pipe do |objs_map|
>     id_list.map{|id| objs_hash[id]}
>   end
>
> Any thoughts?
>

 I would choose a much less arcane solution:

objs_map = {}
Model.where(id: id_list).each {|o| objs_map[o.id] = o}
sorted = id_list.map{|id| objs_map[id]}

If id_list is smallish (< 30 or so) then index lookup might actually be
faster - or at least fast enough.

sorted = Model.where(id: id_list).sort_by {|o| id_list.index(o)}

Kind regards

robert


-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/