ruby - 在 Ruby 中更改 Proc 的绑定(bind)

Question

我有这个代码:

 l = lambda { a }
 def some_function
     a = 1
 end

我只想通过 lambda 访问 a 和一个已经定义了 a 的特殊范围，例如示例中的 some_function 内部，或者不久之后在与以下相同的范围内:

 l = lambda { a }
 a = 1
 l.call

然后我发现在调用l时，它仍然使用它自己的绑定(bind)，而不是调用它的新绑定(bind)。

然后我尝试将其用作:

 l.instance_eval do
     a = 1
     call
 end

但这也失败了，很奇怪我无法解释原因。

我知道其中一个解决方案是使用 eval，我可以在其中特殊绑定(bind)并在文本中执行一些代码，但我真的不想这样使用。

而且，我知道它能够使用全局变量或实例变量。但是，实际上我的代码处于更深的嵌入式环境中，所以如果不是很有必要，我不想破坏已完成的部分。

我在文档中引用了 Proc 类，我发现了一个函数名称 binding 引用了 Proc 的上下文。虽然该函数只提供了一种访问其绑定(bind)的方法，但不能更改它，除非使用 Binding#eval。它还评估文本，这正是我不喜欢做的。

现在的问题是，我是否有更好(或更优雅)的方法来实现它？或者使用 eval 已经是常规方式？

编辑回复@Andrew:
好的，这是我在编写词法解析器时遇到的问题，其中我定义了一个包含固定数量项目的数组，其中至少包括一个 Proc 和一个正则表达式。我的目的是匹配正则表达式并在我的特殊范围内执行Procs，其中Proce会涉及一些局部变量，这些局部变量应该稍后定义。然后我遇到了上面的问题。
实际上我认为它与that question 完全不一样。 ，因为我的是如何将 in 绑定(bind)传递给 Proc，而不是如何将它传递 out。

@尼克拉斯:得到你的答案，我想这正是我想要的。完美解决了我的问题。

Answer 1

您可以尝试以下技巧:

class Proc
  def call_with_vars(vars, *args)
    Struct.new(*vars.keys).new(*vars.values).instance_exec(*args, &self)
  end
end

像这样使用:

irb(main):001:0* lambda { foo }.call_with_vars(:foo => 3)
=> 3
irb(main):002:0> lambda { |a| foo + a }.call_with_vars({:foo => 3}, 1)
=> 4

不过，这不是一个非常通用的解决方案。如果我们可以给它 Binding 实例而不是 Hash 并执行以下操作会更好:

l = lambda { |a| foo + a }
foo = 3
l.call_with_binding(binding, 1)  # => 4

使用以下更复杂的 hack，可以实现这种行为:

class LookupStack
  def initialize(bindings = [])
    @bindings = bindings
  end

  def method_missing(m, *args)
    @bindings.reverse_each do |bind|
      begin
        method = eval("method(%s)" % m.inspect, bind)
      rescue NameError
      else
        return method.call(*args)
      end
      begin
        value = eval(m.to_s, bind)
        return value
      rescue NameError
      end
    end
    raise NoMethodError
  end

  def push_binding(bind)
    @bindings.push bind
  end

  def push_instance(obj)
    @bindings.push obj.instance_eval { binding }
  end

  def push_hash(vars)
    push_instance Struct.new(*vars.keys).new(*vars.values)
  end

  def run_proc(p, *args)
    instance_exec(*args, &p)
  end
end

class Proc
  def call_with_binding(bind, *args)
    LookupStack.new([bind]).run_proc(self, *args)
  end
end

基本上我们为自己定义了一个手动名称查找堆栈和 instance_exec 我们针对它的过程。这是一个非常灵活的机制。它不仅可以实现 call_with_binding，还可以用来构建更复杂的查找链:

l = lambda { |a| local + func(2) + some_method(1) + var + a }

local = 1
def func(x) x end

class Foo < Struct.new(:add)
  def some_method(x) x + add end
end

stack = LookupStack.new
stack.push_binding(binding)
stack.push_instance(Foo.new(2))
stack.push_hash(:var => 4)

p stack.run_proc(l, 5)

如预期的那样打印 15 :)

更新:代码现在也可用at Github .我现在也将其用于我的一个项目。