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
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.