def proc_with_enclosing_scope
name = "Ruby"
lamda { puts name }
end
=> nil
the_proc = proc_with_enclosing_scope
NoMethodError: undefined method `lamda' for main:Object

I think what Dave was trying to illustrate with this example is that
even
though the method that you're calling has gone out of scope that it
still
retains the value of the variable defined inside.

Whats fascinating about this simple example is the fact that the method
which is assigned to a remembers the context of everything defined
internally. Think about that for a second. In languages that do not
support closures the values of the properties defined are lost until the
next time the method is called, however closures not only remember the
values of their properties after the function goes out of scope but the
context in which they were originally defined. Its a pretty simple
concept
but a very powerful one at the same time.

Aldric Giacomoni wrote:

def proc_with_enclosing_scope
name = "Ruby"
lambda { puts name }
end

the_proc = proc_with_enclosing_scope
the_proc.call

name = "Java"
the_proc.call

why would changing the name outside the
method make a difference in the first place?

It doesn't. Did you try the code? Both instances of the_proc.call
return "Ruby". I assume the 'name="Java"' line is just there to point
out that it's not the same variable.

So.... When the_proc gets assigned the ... Value of the method
running... (?) What does it get assigned?

proc_with_enclosing_scope.class
=> Proc


And lastly.. I know that "proc" exists, too. What is the difference /
what does it do?

lambda {} is nearly equivalent to Proc.new {}. See
http://ruby-doc.org/core/classes/Kernel.html#M005945 .

Aldric Giacomoni wrote:
Marnen Laibow-Koser wrote:

In Rails they're occasionally used for callbacks, and in
RSpec I often do things like
lambda {Car.drive}.should_not raise_error

See http://en.wikipedia.org/wiki/Closure_(computer_science)<http://en.wikipedia.org/wiki/Closure_%28computer_science%29>for more.

I'm reading that wiki page right now
About that RSpec example..

You are creating "code which calls Car.drive", yes ? Why not just call
Car.drive ? That is the main bit of thinking I'm having issues with.

Never mind!
I just found this : http://innig.net/software/ruby/closures-in-ruby.rb
Enlightening. Thanks again for your help, it makes it all easier to
read.
--
Posted via http://www.ruby-forum.com/.

So.. Proc and Lambda are .. Pretty much the same thing, according to
Ruby.

So they really are "bits of code with its own environment" ?
When is that useful? Maybe I need to watch Dave Thomas' presentation
again..

Thanks, Marnen.

Not quite. There's no such class as Lambda. Read what I said in my
first post again.

In Rails they're occasionally used for callbacks, and in
RSpec I often do things like
lambda {Car.drive}.should_not raise_error

See http://en.wikipedia.org/wiki/Closure_(computer_science) for more.

This is something I don't understand, and did not understand when I
studied LISP. I just watched Dave Thomas' presentation, "Extending Ruby
for Fun and Profit", which I by the way highly recommend to everyone who
hasn't seen it...
And he has the following example:

def proc_with_enclosing_scope
name = "Ruby"
lambda { puts name }
end

the_proc = proc_with_enclosing_scope
the_proc.call

name = "Java"
the_proc.call

_____

I don't understand what Ruby is doing / what happens.
First question: the "name" variable is defined inside the method
proc_with_enclosing_scope, so why would changing the name outside the
method make a difference in the first place?

Second question: I tried to type this straight into irb and made a small
typo, so it came out as such -

def proc_with_enclosing_scope
name = "Ruby"
lamda { puts name }
end
=> nil
the_proc = proc_with_enclosing_scope
NoMethodError: undefined method `lamda' for main:Object
from (irb):23:in `proc_with_enclosing_scope'
from (irb):25

So.... When the_proc gets assigned the ... Value of the method
running... (?) What does it get assigned?

And lastly.. I know that "proc" exists, too. What is the difference /
what does it do?

I thank you very much in advance for the enlightenment you will provide

--
Posted via http://www.ruby-forum.com/.

This is something I don't understand, and did not understand when I
studied LISP. I just watched Dave Thomas' presentation, "Extending Ruby
for Fun and Profit", which I by the way highly recommend to everyone who
hasn't seen it...
And he has the following example:

def proc_with_enclosing_scope
name = "Ruby"
lambda { puts name }
end

the_proc = proc_with_enclosing_scope
the_proc.call

name = "Java"
the_proc.call

_____

I don't understand what Ruby is doing / what happens.
First question: the "name" variable is defined inside the method
proc_with_enclosing_scope, so why would changing the name outside the
method make a difference in the first place?

Second question: I tried to type this straight into irb and made a small
typo, so it came out as such -

def proc_with_enclosing_scope
name = "Ruby"
lamda { puts name }
end
=> nil
the_proc = proc_with_enclosing_scope
NoMethodError: undefined method `lamda' for main:Object
from (irb):23:in `proc_with_enclosing_scope'
from (irb):25

So.... When the_proc gets assigned the ... Value of the method
running... (?) What does it get assigned?

proc_with_enclosing_scope.class
=> Proc

And lastly.. I know that "proc" exists, too. What is the difference /
what does it do?

I thank you very much in advance for the enlightenment you will provide

Marnen Laibow-Koser wrote:

In Rails they're occasionally used for callbacks, and in
RSpec I often do things like
lambda {Car.drive}.should_not raise_error

See http://en.wikipedia.org/wiki/Closure_(computer_science) for more.

I'm reading that wiki page right now
About that RSpec example..

You are creating "code which calls Car.drive", yes ? Why not just call
Car.drive ? That is the main bit of thinking I'm having issues with.