local_variable_set ?

[Hal Fulton]

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

 

[David A. Black]

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

 

[David A. Black]

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

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

 

[Devin Mullins]

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

 

[Jeremy Kemper]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

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.

Stefan Kaes had a similar request several months ago:

http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/
a954f8aaf698a0b9

Regards,
jeremy
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.2 (Darwin)

iD8DBQFDSgIWAQHALep9HFYRAlpcAJ9LWKCPTC9xNo48mabidEsfShT8PACgw2Fb
AzDR1PMb5LfrhCCmBMTaW0o=
=9z7U
-----END PGP SIGNATURE-----

 

[Mauricio Fernández]

Well, it's feasible now.

http://onestepback.org/index.cgi/Tech/Ruby/RubyBindings.rdoc

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")

 

[Devin Mullins]

The eval("lambda{|x| #{lvar} =3D x}", somebinding).call(val) trick won't
allow you to create new locals and refer to them normally.

Point.