More readable array querying

All,
I’ve been playing with some code to make querying an array more
readable.
Basically, it lets you write one of the following:

puts [1,2,3].first that {|x| x.even? }
puts [1,2,3].first that is :even

instead of this:

puts [1,2,3].find {|x| x.even? }

The code is below. I’m curious whether you’d find it useful,
interesting,
worthwhile, etc., and if there are improvements you can think of. Either
way, it was a fun little exercise. I love the flexibility I get from
writing
in ruby!

module Kernel
def that proc=nil, &block
p = proc.nil? ? block : proc
lambda { |x| x.instance_eval &p }
end

def is message
lambda { |x| x.send “#{message}?”.to_sym }
end
end

class Array
alias :old_first first

def first func=nil
return old_first if func.nil?
each do |x|
return x if func.call x
end
nil
end
end

On Oct 10, 2010, at 13:59 , Andrew W. wrote:

The code is below. I’m curious whether you’d find it useful, interesting,
worthwhile, etc., and if there are improvements you can think of. Either
way, it was a fun little exercise. I love the flexibility I get from writing
in ruby!

I doubt I would ever want to use this. The amount of readability it adds
is completely offset by how much slower it is:

of iterations = 1000000

                      user     system      total        real

null_time 0.090000 0.000000 0.090000 ( 0.095464)
ary.find 1.680000 0.010000 1.690000 ( 1.717772)
ary.first that 18.580000 1.140000 19.720000 ( 23.080667)
ary.first that is 21.770000 0.260000 22.030000 ( 30.326090)

def that proc=nil, &block
p = proc.nil? ? block : proc

p = proc || block

def is message
lambda { |x| x.send “#{message}?”.to_sym }

no need for to_sym at all.

def first func=nil
return old_first if func.nil?
each do |x|
return x if func.call x
end

Any reason why you’re not using find?

Also, if you don’t match, you’re going to return self, which would be
wrong imo.

Thanks for the helpful feedback.

On Oct 10, 3:59 pm, Andrew W. [email protected] wrote:

lambda { |x| x.instance_eval &p }

def first func=nil
return old_first if func.nil?
each do |x|
return x if func.call x
end
nil
end
end

Which is more readable?

2 + 2 = 4
Two added to two is equal to four.

And if you’re interested in readability, why do you say
lambda instead of proc?

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs