No, this isn't April Fool's Day. I'm seriously wondering
if this has ever been considered.
I can only think of one place I'd use it -- to turn hashes
(used as named parameters) into real variables.
Something like:
def meth(hash)
bind = binding
hash.each_pair {|k,v| local_variable_set(k,v,bind) }
# Assuming call was: meth(alpha: 123, beta: 234, gamma: 345)
# we now can reference alpha, beta, and gamma as ordinary
# variables...
end
Thoughts?
Hal
Hi --
No, this isn't April Fool's Day. I'm seriously wondering
if this has ever been considered.I can only think of one place I'd use it -- to turn hashes
(used as named parameters) into real variables.Something like:
def meth(hash)
bind = binding
hash.each_pair {|k,v| local_variable_set(k,v,bind) }
# Assuming call was: meth(alpha: 123, beta: 234, gamma: 345)
# we now can reference alpha, beta, and gamma as ordinary
# variables...
end
I think making bindings writeable has been suggested:
binding[:alpha] = 123
or whatever.
Thoughts?
To me it suggests too tight a coupling between the caller and the
method. If you write a method that depends on being told to create a
local variable with a particular name, you're limiting what can be
done by way of refactoring and reimplementing the method.
David
On Mon, 10 Oct 2005, Hal Fulton wrote:
--
David A. Black
dblack@wobblini.net
Hal Fulton wrote:
No, this isn't April Fool's Day. I'm seriously wondering
if this has ever been considered.
Well, it's feasible now.
http://onestepback.org/index.cgi/Tech/Ruby/RubyBindings.rdoc
And it's been distributed in a couple libraries:
http://nano.rubyforge.org/
http://extensions.rubyforge.org/rdoc/index.html
Your use case is a neat idea. I wonder how it'd make the Rails source code look. 
Devin
Stefan Kaes had a similar request several months ago:
http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/a954f8aaf698a0b9
Regards,
jeremy
On Oct 9, 2005, at 7:35 PM, Hal Fulton wrote:
No, this isn't April Fool's Day. I'm seriously wondering
if this has ever been considered.I can only think of one place I'd use it -- to turn hashes
(used as named parameters) into real variables.
Hi --
Hi --
No, this isn't April Fool's Day. I'm seriously wondering
if this has ever been considered.I can only think of one place I'd use it -- to turn hashes
(used as named parameters) into real variables.Something like:
def meth(hash)
bind = binding
hash.each_pair {|k,v| local_variable_set(k,v,bind) }
# Assuming call was: meth(alpha: 123, beta: 234, gamma: 345)
# we now can reference alpha, beta, and gamma as ordinary
# variables...
endI think making bindings writeable has been suggested:
binding[:alpha] = 123
or whatever.
Thoughts?
To me it suggests too tight a coupling between the caller and the
method. If you write a method that depends on being told to create a
local variable with a particular name, you're limiting what can be
done by way of refactoring and reimplementing the method.
Maybe not, though. I guess the idea would be that the caller is
supposed to send those names in a hash anyway. I think I might find
it weird, though, to see:
def meth(hash)
bind = binding
hash.each_pair {|k,v| local_variable_set(k,v,bind) }
puts alpha
beta += 2
if defined?(gamma)
puts "gamma came from somewhere..."
etc., without having any visual cues (arglist or assignment) as to
where those names came from.
David
On Mon, 10 Oct 2005, David A. Black wrote:
On Mon, 10 Oct 2005, Hal Fulton wrote:
--
David A. Black
dblack@wobblini.net
The eval("lambda{|x| #{lvar} = x}", somebinding).call(val) trick won't
allow you to create new locals and refer to them normally. Taking the
example from the OP:
# hash is {:alpha => 1, :beta => 2, :x => 0}
alpha = beta = nil # you can't get rid of this in the current implementation
bind = binding
hash.each_pair {|k,v| local_variable_set(k,v,bind)
# we can use alpha & beta normally, but x requires eval("x")
On Mon, Oct 10, 2005 at 12:57:27PM +0900, Devin Mullins wrote:
Hal Fulton wrote:
>No, this isn't April Fool's Day. I'm seriously wondering
>if this has ever been considered.Well, it's feasible now.
http://onestepback.org/index.cgi/Tech/Ruby/RubyBindings.rdoc
--
Mauricio Fernandez
Mauricio Fernández wrote:
The eval("lambda{|x| #{lvar} = x}", somebinding).call(val) trick won't
allow you to create new locals and refer to them normally.
Point.