更改Ruby proc / block的结构

Question

I am not sure if this is possible in Ruby, but in case someone knows a good solution.

I'd like to change the structure of a block, replacing particular nodes in it with other code structures. Much like macros.

For example, say I have an unevaluated code block

some_method do
  foo
  bar
end

Then I define some_method like

def some_method(&block)
   ...
end

In some_method, I really would like to replace "bar" in block with something else, eg with baz.

I want to do the replacement w/o evaluating the block, because ultimately I am passing the block around to other places.

Doable? or no?

I can think of fairly complicated answers: eg I can pass the block around with an additional closure that defines replacement for bar, and uses method_missing and continuation to replace bar with baz when bar is evaluated. But is there a simpler way?

Thanks.

Answer 1

Ruby doesn't have dynamic scoping and doesn't have macros, so unless you wrap the block in a function taking bar as a parameter, and pass that function around, I don't think you can substitute code like that. You can use eval of course, but I wouldn't recommend it=)

Answer 2

This is the simplest way i can think of:

class Base
  def some_method(&block)
     self.instance_eval(&block)
  end
  def foo; puts 'foo'; end
  def bar; puts 'bar'; end
end

class Replacement < Base
  def foo; puts 'baz'; end
end

Base.new.some_method do
  foo
  bar
end

Replacement.new.some_method do
  foo
  bar
end

output:

foo
bar
baz
bar

Answer 3

Do aliases and Procs help?

def foo; p 'foo'; end
def bar; p 'bar'; end
def sm(&block)
    @@Block = Proc.new {
        alias :oldbar :bar
        def bar; p 'baz'; end  #redefine
        block.call
        alias :bar :oldbar  #restore
    }
    yield    #prints foo,bar
end


sm do 
    foo 
    bar
end


def later(&block)
    yield
end
def delayedEx
    later { @@Block.call}
end

delayedEx  #prints foo,baz
bar  #prints bar (unchanged)

This prints "foo bar foo baz bar", ie: bar does something different in the block, but retains its original behavior outside.

Answer 4

def some_method(a_proc=Proc.new{puts "Bar"}, &block)
  a_proc.call
  yield
end

p1 = Proc.new{puts "Baz"}

some_method{puts "a block"}
some_method(p1){puts "a block"}