How does ruby handle scope and closure in this case?

Ruby
#1

How come when I do something like

#!/usr/bin/ruby -w

def n_times(thing)
return thing
end

pi = n_times(23);
puts pi

the variable ‘thing’ doesn’t go out of scope.

But when I do something like

#!/usr/bin/ruby

def n_times(thing)
return lambda{|n| thing * n}
end

pi = n_times(23);
puts pi.call(2)

The varialble ‘thing’ does go out of scope.

#2

Hi,

I think it’s a excution stack thing, you should look a the C code if you
want to understand ruby magic.

Hope I got your question, otherwise the text you got this example from
describes fairly good why the ‘thing’ (or aThing) variable ‘gets’ out of
scope (its refence is still hold by the Proc object).

Even in the first case you should got the Object out of scope since you
passed the reference:

def n_times(thing)
puts thing.object_id
return thing
end

pi = n_times(23)
puts pi.object_id

Regards
Florian

#3

On Aug 29, 2007, at 8:25 PM, grocery_stocker wrote:

the variable ‘thing’ doesn’t go out of scope.

I think it does. The variable ‘thing’ from #n_times is not visible at
top level. If you were to do

puts thing

at this point, you would get an error.

Regards, Morton

#4

Florian Aßmann wrote:

Hi,

I think it’s a excution stack thing, you should look a the C code if you
want to understand ruby magic.

Hope I got your question, otherwise the text you got this example from
describes fairly good why the ‘thing’ (or aThing) variable ‘gets’ out of
scope (its refence is still hold by the Proc object).

Even in the first case you should got the Object out of scope since you
passed the reference:

def n_times(thing)
puts thing.object_id
return thing
end

pi = n_times(23)
puts pi.object_id

Regards
Florian

This example will give a false impression. Fixnum’s always have the
same ID regardless of scope. try this smae test with something other
then a small integer:

var = n_times(Object.new)
puts var.object_id

It will give you a much better sense of what is going on.

John M.

#5

2007/8/30, grocery_stocker [email protected]:

pi = n_times(23);
puts pi.call(2)

The varialble ‘thing’ does go out of scope.

Does it?

$ ruby<<XXX

def n_times(thing)
return lambda{|n| thing * n}
end

pi = n_times(23);
puts pi.call(2)
puts thing
XXX
46
-:7: undefined local variable or method `thing’ for main:Object
(NameError)

Ruby has static scoping rules but, err, can’t remember the proper
term, dynamic binding. When you create the lambda you create a
closure which keeps references in its environment alive.

Kind regards

robert

#6

On 8/31/07, Robert K. [email protected] wrote:

puts pi
end
def n_times(thing)
Ruby has static scoping rules but, err, can’t remember the proper
term, dynamic binding. When you create the lambda you create a
closure which keeps references in its environment alive.

Kind regards

robert

Hmm it might be a case where object and variable could easily get
confused, I have jotted down a little example which, I hope, shows
what is going on here:

------------------ 8< ----------------
def a param
proc { param << “.” }
end
def b param
proc { param = param + “.” }
end

o = “42”
p = a o
q = a o
puts p.call
puts p.call
puts q.call
puts o

–>42.
–>42…
–>42…
–>42…

o = “42”
p = b o
q = b o
puts p.call
puts p.call
puts q.call
puts o
–>42.
–>42…
–>42.
–>42

Cheers
Robert