Hello,
So I was reading the brief discussion on named parameters in the
gigantic troll-fueled thread (forward
note, the hash option wasn’t discussed, and I do know about it, so I
don’t need to be lectured 
), and I
saw the example of named parameters in a constructor like so:
class Foo
attr_accessor :foo, :bar
def initialize
…
yield self if block_given?
end
end
Foo.new { |obj| obj.foo = 5; obj.bar = 6 }
And someone liked it. However, this isn’t really any better than:
obj = Foo.new
obj.foo = 5
obj.foo = 6
Unless you make the accessors private, in which case I think you need to
instance_eval the block.
So, I got to thinking of a way to possibly use a block to assign to
local variables. For example,
thinking of the up-and-coming scoping rule changes, maybe one could do:
class Foo
def initialize(&blk)
if blk
instance_eval &blk
end
@height = height
end
end
Foo.new do height = 5 end
However, then I thought, perhaps this already works like so:
class Foo
def initialize(height=nil, &blk)
if blk then instance_eval &blk end
@height = height
end
end
Since height will be defined as a local variable, and should propogate
out. However, instance_eval
doesn’t work this way, so I doubt that it will work with the new scoping
rules.
So, finally for my question:
instance_eval, class_eval and module_eval all optionally take code
blocks to evaluate in a certain
context. However, eval itself only takes a string. Is there, or will
there ever be a way to evaluate
a code block with an arbitrary binding object/in an arbitrary context,
so that something like the
above will work? I suppose a block used in such a way is no longer a
closure, but it could be
an interesting addition to Proc’s (note, I’m not sure how much utility
it would have outside this
example).
Until then, I think the closest I can come to named parameters using
blocks is:
class Foo
def initialize(&blk)
if blk
bnd = blk.call
@height = eval “height”, bnd
end
end
end
Foo.new do height = 6; binding end
Then again, writing to allow:
Foo.new(:height => 6)
Isn’t terribly hard, looks fine, and allows you to still pass a block
for other purposes if you need it,
so I don’t think things should be changed merely for this example’s sake.
Anyhow, any thoughts on all this? Thanks in advance for the stuff I’ll
probably learn from any discussion
that ensues.
- Dan