I'm currently playing with proc and code block as parameter trying to
learn this aspect. Bellow is some code: three sections. The first one
explain by itself what I whant to do, except that I would like to use
classes. The second is the same in my point of view than the first one
and using a class... but it's now doing what I was expecting. The third
one is working but I don' understand why it should be like this.
Anybody can give me the reason?
Thanks.
Yannick
···
---------------------------------
##### FIRST SECTION #####
puts "First section"
def fn(text)
return proc{|factor| puts text * factor}
end
f = fn("Joe ")
f.call(3) #It prints "Joe Joe Joe ", as expected.
##### SECOND SECTION #####
puts "Second section"
class Bob
def initialize(factor, &block) @factor = factor @action = block
end
def run @action.call(@factor)
end
end
b = Bob.new(3){f}
b.run #It prints nothing [b.run return the function returned by
fn()]
##### THIRD SECTION #####
puts "Third section"
#Redefine run()
class Bob
def run @action.call.call(@factor) #Why should I call "call"
twice. Isn't @action supposed to be the function returned by fn()?
end
end
b = Bob.new(3){f}
b.run() #It prints "Joe Joe Joe ".
---------------------------------
I'm currently playing with proc and code block as parameter trying to
learn this aspect. Bellow is some code: three sections. The first one
explain by itself what I whant to do, except that I would like to use
classes. The second is the same in my point of view than the first one
and using a class... but it's now doing what I was expecting. The third
one is working but I don' understand why it should be like this.
Anybody can give me the reason?
Thanks.
Yannick
---------------------------------
##### FIRST SECTION #####
puts "First section"
def fn(text)
return proc{|factor| puts text * factor}
end
f = fn("Joe ")
f.call(3) #It prints "Joe Joe Joe ", as expected.
##### SECOND SECTION #####
puts "Second section"
class Bob
def initialize(factor, &block) @factor = factor @action = block
end
def run @action.call(@factor)
end
end
b = Bob.new(3){f}
b.run #It prints nothing [b.run return the function returned by
fn()]
##### THIRD SECTION #####
puts "Third section"
#Redefine run()
class Bob
def run @action.call.call(@factor) #Why should I call "call"
twice. Isn't @action supposed to be the function returned by fn()?
end
end
b = Bob.new(3){f}
b.run() #It prints "Joe Joe Joe ".
---------------------------------
@action is the block. @action.call excutes the block which returns f
f.call prints "Joe Joe Joe "
---------------------------------
##### FIRST SECTION #####
puts "First section"
def fn(text)
return proc{|factor| puts text * factor}
end
f = fn("Joe ")
f.call(3) #It prints "Joe Joe Joe ", as expected.
##### SECOND SECTION #####
puts "Second section"
class Bob
def initialize(factor, &block) @factor = factor @action = block
end
def run @action.call(@factor)
end
end
b = Bob.new(3){f}
b.run #It prints nothing [b.run return the function returned by fn()]
Just because you've specified so. @action is {f} which means if you
call, it evaluates the variable reference f and gives you its value.
##### THIRD SECTION #####
puts "Third section"
#Redefine run()
class Bob
def run @action.call.call(@factor) #Why should I call "call" twice. Isn't @action supposed to be the function returned by fn()?
end
end
b = Bob.new(3){f}
b.run() #It prints "Joe Joe Joe ".
Just because you've specified so. Since @action is {f} as above, the
first "call" gives you f, you have to call it again to invoke the f
"function".
matz.
···
In message "Re: Proc as a parameter in a class" on Tue, 9 Aug 2005 06:21:08 +0900, "Yannick Turgeon" <vendredi5h@gmail.com> writes:
I'm currently playing with proc and code block as parameter trying to
learn this aspect. Bellow is some code: three sections. The first one
explain by itself what I whant to do, except that I would like to use
classes. The second is the same in my point of view than the first
one and using a class... but it's now doing what I was expecting.
The third one is working but I don' understand why it should be like
this. Anybody can give me the reason?
Thanks.
Yannick
---------------------------------
##### FIRST SECTION #####
puts "First section"
def fn(text)
return proc{|factor| puts text * factor}
end
f = fn("Joe ")
f.call(3) #It prints "Joe Joe Joe ", as expected.
##### SECOND SECTION #####
puts "Second section"
class Bob
def initialize(factor, &block) @factor = factor @action = block
end
def run @action.call(@factor)
end
end
b = Bob.new(3){f}
b.run #It prints nothing [b.run return the function returned
by fn()]
##### THIRD SECTION #####
puts "Third section"
#Redefine run()
class Bob
def run @action.call.call(@factor) #Why should I call "call"
twice. Isn't @action supposed to be the function returned by fn()?
end
end
b = Bob.new(3){f}
b.run() #It prints "Joe Joe Joe ".
---------------------------------
@action is the block. @action.call excutes the block which returns f
f.call prints "Joe Joe Joe "
cheers
Simon
Here's another variant: the proc is reconverted to a block:
##### SECOND SECTION #####
puts "Second section"
class Bob
def initialize(factor, &block) @factor = factor @action = block
end
def run @action.call(@factor)
end
end
# note the end of next line
b = Bob.new(3, &f)
b.run #It prints nothing [b.run return the function returned by
fn()]
Here's another variant: the proc is reconverted to a block:
# note the end of next line
b = Bob.new(3, &f)
b.run
Interesting. So the "&" convert a proc to a block. So can I conclude
that there is no way to use:
b = Bob.new(3){<some code here>}
to pass fn returned value (a proc) as a block parameter to Bob.new.
You're way is the only way?