using Proc and yield

[Alber Eric]

hi !

I'm new to ruby and I'm currently testing the language. So I know I can
write this:

def hello()
yield "hello world"
end

hello { |i| puts i }

This prints "hello world" on the console, cool.

Now I wonder if the following code is valid :

p = Proc.new { yield "hello world" }

p.call { |i| puts i }

when I execute this I get the following error :
LocalJumpError: no block given
from (irb):83
from (irb):85:in `call'
from (irb):85
from :0


I belived Proc.call was equivalent to a standard method call, it seems
I'm wrong . Did I misunderstand something? Can someone tell me where I
made a mistake?

Thank you

 

[Alber Eric]

OK, thank you for your quick answer

I will just expose what I'm trying to do : I have four differents
methods that are yielding strings. I want to use one or the other
depending on the context but the rest of the process is the same, so I
wrote something like that

p1 = nil
p2 = nil

# First argument handling
case arg1
when 1
p1 = Proc.new { methodI { |s| yield s } }
when 2
p1 = Proc.new { methodII { |s| yield ("foo-" + s + "-bar") } }
end

# Second argument handling
case arg2
when 3
p2 = Proc.new { methodIII { |s| yield s } }
when 4
p1 = Proc.new { methodIV { |s| yield ("oof-" + s + "-rab") } }
end

p1.call { |i|
p2.call { |j|
process(i)
}
}

What I'm looking for is a sort of function pointer.

Thanks

Eric

 

[Alber Eric]

At the end, read process(i, j) instead of process(i)

 

[Tim Pease]

OK, thank you for your quick answer

I will just expose what I'm trying to do : I have four differents
methods that are yielding strings. I want to use one or the other
depending on the context but the rest of the process is the same, so I
wrote something like that

p1 = nil
p2 = nil

# First argument handling
case arg1
when 1
p1 = Proc.new { methodI { |s| yield s } }
when 2
p1 = Proc.new { methodII { |s| yield ("foo-" + s + "-bar") } }
end

# Second argument handling
case arg2
when 3
p2 = Proc.new { methodIII { |s| yield s } }
when 4
p1 = Proc.new { methodIV { |s| yield ("oof-" + s + "-rab") } }
end

p1.call { |i|
p2.call { |j|
process(i)
}
}

What I'm looking for is a sort of function pointer.

def p1( arg )
yield arg
end

def p2( arg )
yield arg
end

# First argument handling
case arg1
when 1: nil # p1 already defined correctly
when 2
eval %(
def p1( arg )
yield( "foo-" + arg + "-bar" )
end
)
end

# Second argument handling
case arg2
when 3: nil # p2 already defined correctly
when 4
eval %(
def p1( arg )
yield ("oof-" + arg + "-rab")
end
)
end

p1( arg1 ) do |i|
p2( arg2 ) do |j|
process(i,j)
end
end


No need for function pointers. Just define (or redefine) the methods
as you need them.

Blessings,
TwP

 

[George Ogata]

OK, thank you for your quick answer

I will just expose what I'm trying to do : I have four differents
methods that are yielding strings. I want to use one or the other
depending on the context but the rest of the process is the same, so I
wrote something like that

[...]

What I'm looking for is a sort of function pointer.

Hi Eric,

Blocks can't take blocks in 1.8, so I think you'll need to resort
to methods if you do it this way. Example:

def methodI_foo_bar
methodI{|s| yield "foo-#{s}-bar"}
end
def methodIII_oof_rab
methodIII{|s| yield "oof-#{s}-rab"}
end

# First argument handling
case arg1
when 1
p1 = methodmethodI)
when 2
p1 = methodmethodI_foo_bar)
end

# Second argument handling
case arg2
when 3
p2 = methodmethodIII)
when 4
p2 = methodmethodIII_oof_rab)
end

p1.call { |i|
p2.call { |j|
process(i, j)
}
}

Or, perhaps more idiomatically:

def methodI_foo_bar
methodI{|s| yield "foo-#{s}-bar"}
end
def methodIII_oof_rab
methodIII{|s| yield "oof-#{s}-rab"}
end

# First argument handling
case arg1
when 1
m1 = :methodI
when 2
m1 = :methodI_foo_bar
end

# Second argument handling
case arg2
when 3
m2 = :methodIII
when 4
m2 = :methodIII_oof_rab
end

send(m1) { |i|
send(m2) { |j|
process(i, j)
}
}

Does that help?