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
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!
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.
And if you're interested in readability, why do you say
lambda instead of proc?
···
On Oct 10, 3:59 pm, Andrew Wagner <wagner.and...@gmail.com> wrote:
[Note: parts of this message were removed to make it a legal post.]
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 Sun, Oct 10, 2010 at 6:23 PM, Ryan Davis <ryand-ruby@zenspider.com>wrote:
On Oct 10, 2010, at 13:59 , Andrew Wagner wrote:
> 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!
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