Scope of block

Ruby
1

Hello i have a question about scopes of block
I want to define a block at one time.
But when it get’s called it should have the scope (vars ed )
of the calling environement

Example :

class BlockTest

attr_accessor :myblock

def process(&block)
self.myblock = block
end
end

t = BlockTest.new
t.process {

“var = #{out_of_scope_var}”
}

out_of_scope_var = “daniel”
p t.myblock.call

Results in :

blocktest.rb:15: undefined local variable or method `out_of_scope_var’
for main:Object (NameError) from blocktest.rb:19

How can i call the proc so that the out_of_scope_var is known :

result would be :

so i would get :

daniel-wijnands-powerbook58-2:~/jim/vendor/plugins/widget_grid/lib
danielwijnands$ ruby blocktest.rb
“var = daniel”

2

daniel wrote:

Hello i have a question about scopes of block
I want to define a block at one time.
But when it get’s called it should have the scope (vars ed )
of the calling environement

Perhaps you will be satisfied that the block receive values from the
parent
environment. This is the normal way to solve the problem.

#!/usr/bin/ruby -w

class BlockTest

attr_accessor :myblock
def process(&block)
self.myblock = block
end
end

t = BlockTest.new
t.process{ |v|
“var = #{v}”
}

v = “daniel”
p t.myblock.call(v)

“var = daniel”

3

Paul L. schreef:

Perhaps you will be satisfied that the block receive values from the parent
environment. This is the normal way to solve the problem.

That is how it is solved now, but the proc needs to be flexible.
I call much proc’s and i don’t now what to pass.
It are not just vars that i want to accessible but also methods ed

Any idea ?

4

daniel wrote:

It are not just vars that i want to accessible but also methods ed

Any idea ?

Use instance variables.

#!/usr/bin/ruby -w

class BlockTest
attr_accessor :val
attr_accessor :myblock
def process(&block)
self.myblock = block
end
end

t = BlockTest.new
t.val = “Daniel”
t.process {
“var = #{t.val}”
}

p t.myblock.call

I understand this is not a particularly pretty example, it is just meant
to
show one approach.

5

daniel wrote:

attr_accessor :myblock
“var = #{out_of_scope_var}”
How can i call the proc so that the out_of_scope_var is known :

The following seems to work:
#########
class BlockTest
def process(&block)
@block=block
end

def myblock
instance_eval{@block}.call
end
end

out_of_scope_var = “out of scope, me”
t = BlockTest.new
t.process {“var = #{out_of_scope_var}”}

p t.myblock
#=> “var = out of scope, me”
###########
Hope this helps,
Gustav P.

6

Hi –

On Mon, 11 Dec 2006, Gustav P. wrote:

The following seems to work:
#########
class BlockTest
def process(&block)
@block=block
end

def myblock
instance_eval{@block}.call

No need for instance_eval there. @block already belongs to self, and
the instance_eval just resets self to self :slight_smile:

David

7

Gustav P. schreef:

end

out_of_scope_var = “out of scope, me”
t = BlockTest.new
t.process {“var = #{out_of_scope_var}”}

p t.myblock
#=> “var = out of scope, me”
###########
Hope this helps,
Gustav P.

Hi paul, i know that’s works, but i need it slightly differtent
because you set out_of_scope_var before you create the block
I want it to be accessible when you set it after you create the block
With your method it is in the scope of the block
I want the block to have access to the scope when you call it
So this should work :

class BlockTest
def process(&block)
@block=block
end
def myblock
instance_eval{@block}.call
end
end

t = BlockTest.new
t.process {“var = #{out_of_scope_var}”}

out_of_scope_var = “out of scope, me”
p t.myblock

But that gives :

blocktest.rb:40: undefined local variable or method out_of_scope_var' for main:Object (NameError) from blocktest.rb:34:inmyblock’
from blocktest.rb:45

:frowning: thanks anyway :slight_smile:

8

[email protected] wrote:

def myblock
instance_eval{@block}.call

No need for instance_eval there. @block already belongs to self, and
the instance_eval just resets self to self :slight_smile:

David

LOL!
doh!
:-]

9

you could add an eval() into your example code, so that:

t = BlockTest.new
t.process { "var = #{out_of_scope_var}" }
out_of_scope_var = "daniel"
p t.myblock.call

would become:

t = BlockTest.new
t.process { "var = #{eval('out_of_scope_var'}" }
out_of_scope_var = "daniel"
p t.myblock.call

hope that helps. --noon

10

oops, i forgot to put the closing paren. should be:

t.process { "var = #{eval('out_of_scope_var')}" }

–noon