Re: Symbol#to_proc helping out with #select to beat Scala-s solution

I still don't understand why modifying Enumerable didn't work, but i
tried with Array instead and made this solution:
class Array
  %w[select map sort_by].each {|m| class_eval %Q[alias_method :_#{m},
m; def #{m}█ _#{m} {|x| x.instance_eval &block} end]}
end

That allows me to write the example above like this:
sales.select{value > 50000}.map{buyer}.sort_by{age}

It's not too bad, i think. I mean, it's not less readable as it is
with regular block/&: syntax.

Jarmo

On Feb 26, 2:51=A0am, Jarmo Pertman <[e-mail]> wrote:
> I tried to modify the methods directly in Enumerable and succeeded
> only 50%.
>
> Consider the code below:
> module Enumerable
> =A0 def select
> =A0 =A0 puts 1
> =A0 end
> end
>
> class Array
> =A0 include Enumerable
> end
>
> [2,3].select # doesn't print 1
>
> If i use find_all instead then it works:
> module Enumerable
> =A0 def find_all
> =A0 =A0 puts 1
> =A0 end
> end
>
> class Array
> =A0 include Enumerable
> end
>
> [2,3].find_all # prints 1
>
> Now i'm confused as to why isn't #select working as i was hoping for?
>
> Jarmo
>
> On Feb 26, 1:43=A0am, Sean O'Halpin <[e-mail]> wrote:
>
>
>
>
>
>
>
> > [snip]
>
> > > I'm thinking that one possible way to shorten my calls would be to us=
e
> > > instance-eval in #select, #map and #sort_by so i could do it like
> > > this:
> > > sales.select{value > 50000}.map{buyer}.sort_by{age}
>
> > Here's a trivial implementation of that idea:
>
> > module Relational
> > =A0 def project(&block)
> > =A0 =A0 map { |x| x.instance_eval(&block) }
> > =A0 end
>
> > =A0 def where(&block)
> > =A0 =A0 select { |x| x.instance_eval(&block) }
> > =A0 end
>
> > =A0 def order_by(&block)
> > =A0 =A0 sort_by { |x| x.instance_eval(&block) }
> > =A0 end
> > end
>
> > class Buyer < Struct.new(:name, :age)
> > end
>
> > class Sale < Struct.new(:value, :buyer)
> > end
>
> > alice =3D Buyer["Alice", 30]
> > bob =3D Buyer["Bob", 40]
> > charlie =3D Buyer["Charlie", 50]
>
> > sales =3D [
> > =A0 =A0 =A0 =A0 =A0Sale[80000, alice],
> > =A0 =A0 =A0 =A0 =A0Sale[40000, bob],
> > =A0 =A0 =A0 =A0 =A0Sale[60000, charlie],
> > =A0 =A0 =A0 =A0 ]
>
> > class Array
> > =A0 include Relational
> > end
>
> > p sales.where{ value > 50000 }.project{ buyer }.order_by{ age }
> > # =3D> [#<struct Buyer name=3D"Alice", age=3D30>, #<struct Buyer
> > name=3D"Charlie", age=3D50>]
>
> > # But it becomes uglier when you want to do this:
> > p sales.where{ value > 50000 }.project{ [value, buyer] }.order_by{ self=
[1].age }
> > # =3D> [[60000, #<struct Buyer name=3D"Alice", age=3D30>], [80000, #<st=
ruct
> > Buyer name=3D"Charlie", age=3D50>]]
>
> > # Better to do it this way round:
> > p sales.where{ value > 50000 }.order_by{ buyer.age }.project{ [value, b=
uyer] }
> > # =3D> [[60000, #<struct Buyer name=3D"Alice", age=3D30>], [80000, #<st=
ruct
> > Buyer name=3D"Charlie", age=3D50>]]
>
> > However, in practice, I don't use it. Ruby's block syntax is perfectly
> > elegant as it is. Why not be content with it?
>
> > Regards,
> > Sean