But it fails as you can see. Trying to fully grasp what’s going on with
Symbol#to_proc makes my head hurt a little bit (it is only 9.16am here)
and i’m clearly not getting it. Can anyone explain?
But it fails as you can see. Trying to fully grasp what’s going on with
Symbol#to_proc makes my head hurt a little bit (it is only 9.16am here)
and i’m clearly not getting it. Can anyone explain?
The block argument (prefixed with ‘&’) must be the last argument in the
list
when calling a method, so passing ‘l’ in your example is not valid
syntax.
You could rewrite Symbol#to_proc to take arguments, and call #to_proc
explicitly when calling #collect.
class Symbol
def to_proc(*args)
lambda { |o| o.send(self, *args) }
end
end
That’s going to be incomprehensible, except by guesswork, to anyone
who doesn’t know that you’ve modified Symbol. It also undoes whatever
benefit you might get from the &obj idiom automatically calling #to_proc. I’d just do:
array.map {|e| e.split(‘l’) }
No real reason to second-guess Ruby on this. If you really want to
modify Symbol, creating an entirely new method would probably be
better:
I would automatically shy away from overriding to_proc as it seems like
the sort of thing that would slip a timebomb under my app
I was just wondering if it was possible as is, not because it’s soooo
much work to write out a proper block, but simply out of curiosity. “No
you can’t” is a good enough answer for me.
What got me wondering actually was using a Ramaze based framework and
missing lots of nice ways that rails extends the core ruby classes (with
Symbol#to_proc being an example). Is it easy to just require all of
these gems/modules and get the same stuff back? I guess i should answer
my own question by just trying it, so feel free to just say “why not try
it and see?”.
What got me wondering actually was using a Ramaze based framework and
missing lots of nice ways that rails extends the core ruby classes (with
Symbol#to_proc being an example). Is it easy to just require all of
these gems/modules and get the same stuff back? I guess i should answer
my own question by just trying it, so feel free to just say “why not try
it and see?”.
What got me wondering actually was using a Ramaze based framework and
missing lots of nice ways that rails extends the core ruby classes (with
Symbol#to_proc being an example). Is it easy to just require all of
these gems/modules and get the same stuff back? I guess i should answer
my own question by just trying it, so feel free to just say “why not try
it and see?”.
Dave T.'s explanation on this page
(irb):12: syntax error, unexpected ‘,’, expecting ‘)’
end
array.map {|e| e.split(‘l’) }
I wouldn’t say it’s incomprehensible since it maintains the existing
semantics of Symbol#to_proc. The explicit block version is shorter
though,
and will likely perform better.
No real reason to second-guess Ruby on this. If you really want to
modify Symbol, creating an entirely new method would probably be
better:
The real problem here is that a Symbol contains a single piece of
information, whereas we want to build a Proc from several pieces of
information. So, an alternative:
class Array
def to_proc
lambda { |o| o.send(first, *self[1…-1]) }
end
end
It’s still not a huge saving over the explicit block, but I think it’s
worth
knowing how you can manipulate the language for times when it becomes really useful.
missing lots of nice ways that rails extends the core ruby classes (with
Symbol#to_proc being an example). Is it easy to just require all of
these gems/modules and get the same stuff back? I guess i should answer
my own question by just trying it, so feel free to just say “why not try
it and see?”.
They idea was not to change #to_proc but to enhance the Enumerable
behavior.
But please be warned about Labrador it is not actively maintained.
However you might find some inspiration in the source.
class Symbol
who doesn’t know that you’ve modified Symbol. It also undoes whatever
benefit you might get from the &obj idiom automatically calling #to_proc. I’d just do:
array.map {|e| e.split(‘l’) }
I wouldn’t say it’s incomprehensible since it maintains the existing
semantics of Symbol#to_proc.
I don’t think that’s right. The existing semantics don’t include any
arguments. So my reaction would be: isn’t that going to raise an
exception? Then I’d have to figure out that you’d probably overridden
then method.
The real problem here is that a Symbol contains a single piece of
information, whereas we want to build a Proc from several pieces of
information.
Just rename your override of #to_proc to #to_proc_with_args (or
whatever). It will still work the same. (You’re dispensing with the
automatic calling of #to_proc anyway.)
So, an alternative:
class Array
def to_proc
lambda { |o| o.send(first, *self[1…-1]) }
That doesn’t differ from send(*self), does it?
David
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.