I don’t know if this was posted previously, but I had the idea of a
Array#to_proc, an example would be:
[9, 19, 29].map(&[:succ, :to_s, :reverse])
=> [“01”, “02”, “03”]
I’ve seen people ask questions such as arr.map(&‘meth1.meth2.meth3’)
but I think using the Array#to_proc solution is cleaner.
Would this actually prove useful? It would seem that using the normal
block form would be just as much typing, though.
On Jul 1, 2006, at 8:27 AM, Matthew H. wrote:
block form would be just as much typing, though.
–
Matt
This could very soon start to look like line noise:
e.g.
[9, 19, 29].map(&%w{succ to_s reverse})
Symbol#to_proc is one thing (although I don’t like it), Array#to_proc
is too out there, IMO.
Matthew H. wrote:
block form would be just as much typing, though.
Well, unless Array’s got something else to do with #to_proc, it doesn’t
seem to me a dab things per say. What might be more intersting though
is what I suggsed in the Symbol.to_proc is beautiful thead combined
with a way to force +self+ to be passed rather then the result. It
would be something like:
[9, 19, 29].map.succ!.to_s!.reverse
=> [“01”, “02”, “03”]
Where the ! is forcing self to be returned rather then the regular
result. I’m not even sure this would conflict with the defintion of
#succ! either. Altghough it could conflict with other defintions of
bang methods that don’t return self (rare but out there). Is ther an
alternate notation?
Oh. While were at it:
class Hash
def to_proc
Proc.new { |o|
each {|k,v| o.send("#{k}=", v)
}
end
end
Usage:
class X
attr_accessor :a, :b
def initialize( &blk )
blk[self]
end
end
h = {:a=>1, :b=>2}
X.new( &h )
Of course, it’s still no as good as uniform parameters, eg no special
form for blocks.
T.
Matthew H. wrote:
block form would be just as much typing, though.
I’d rather do this:
class Proc
def +(other)
proc {|*args|
args = [self.call(*args)]
other.call(*args)
}
end
end
[9, 19, 29].map( &:succ + &:to_s + &:reverse )
#=> [“01”, “02”, “03”]
but I’m just weird like that
Is this useful for anything? It looks like it should be, but I can’t
think of what…
On 7/1/06, Alex Y. [email protected] wrote:
Would this actually prove useful? It would seem that using the normal
end
–
Alex
Hi,
I get a “parse error, unexpected tAMPER” with ruby 1.8.4 (2005-12-24)
[i386-mswin32].
What version are you using?
How about something like this:
module Enumerable
def cascade(*methods)
methods.inject(self) { |ary, method| ary.map{ |x| x.send(method)}}
end
end
res = [9, 19, 29].cascade :succ, :to_s, :reverse
p res
#=> [“01”, “02”, “03”]
Unless you prefer the line noise of course
Regards,
Sean
Alex Y. [email protected] writes:
[9, 19, 29].map( &:succ + &:to_s + &:reverse )
#=> [“01”, “02”, “03”]
but I’m just weird like that
Lovely. Too bad we can’t overload “.”
Alex Y. wrote:
[9, 19, 29].map(&[:succ, :to_s, :reverse])
=> [“01”, “02”, “03”]
I’d rather do this:
…
[9, 19, 29].map( &:succ + &:to_s + &:reverse )
#=> [“01”, “02”, “03”]
I also wrote similar code for my project:
http://rubyforge.org/cgi-bin/viewvc.cgi/blockutils/?root=blockutils
That includes the other utility functions for ruby-1.9, but can’t work
with ruby-1.8.
Regards,