One of the handy tools that Ruby makes available to us Domain Specific Pidgin builders is instance_eval. With instance_eval you can take a block that was created in one context, with all its lovely closed over local variables, and evaluate it in the context of an instance of an arbitrary object. Which means that any references to instance variables and calls to methods are made as if your block were a 0 argument method of that class. It’s really potent, but at the same time, a little frustrating.

Frustrating? Why frustrating?

Well, it would be really cool if you could call `instance_eval` with a block that took some arguments. That way, you could inject some values into the block from still another scope. (Yes, it’s arcane, but in the places where it would be handy it would be really handy).

I just worked out how to do it:

def my\_instance\_eval(\*args, &block)
return instance\_eval(\*args,&block) unless block\_given? && !block.arity.zero?
self.class.send(:define\_method, :**, &block)
returning(**(\*args)) do
self.class.send(:remove\_method, :**)
end
end


There's problems with that though, the most obvious one being that there's no guarantee that `__` won't already exist as a method or that our block won't *call* `__`. Here's a safer, if scarier option:



def my\_instance\_eval(\*args, &block)
return instance\_eval(\*args,&block) unless block\_given? && !block.arity.zero?
old\_method = (self.class.instance\_method(:**) rescue nil)
self.class.send(:define\_method, :**, &block)
block\_method = self.class.instance\_method(:**)
if old\_method
self.class.send(:define\_method, :**, old\_method)
else
self.class.send(:remove\_method, :**)
end
block\_method.bind(self).call(\*args)
end


This should work even in the face of being called with something along the lines of `object.my_instance_eval(10) {|v| v + __}`. Of course, there would be no point in calling like that. You'd only really need it when you want to do something like `object.my_instance_eval(10,&a_block_param)`.

In the project I'm currently working, where the need for this arose, I shall probably extract the body of `my_instance_eval` to `Proc#to_unbound_method`, that way, instead of hanging onto Block objects I can hang onto UnboundMethod objects and avoid repeatedly shuffling methods.

### But... how does it work?

I hope the code's reasonably obvious. However...

The essence of it is that real methods get to take arguments, so what we need is some way of turning our block into a real method without altering the behaviour/interface of our object. Ruby does allow us create `UnboundMethod` objects which can be thought of as anonymous methods. To use them you have to bind them to a specific instance and then call them, which is the last thing we do in `my_instance_eval`. The intervening code is what turns our Proc into an `UnboundMethod`. First, we stash the old `__` method, or a `nil` if there wasn't one. Then we define a new `__` using our block, and immediately use `instance_method` to get it back as an `UnboundMethod`. Then we either replace the old definition of `__` or simply remove the new one, restoring the original behaviour of our class. Then we bind our new anonymous method to `self` and call it with our arguments. Easy.

### Exercises for the interested reader

-   What happens if our class has `method_removed` or `method_added` implemented? Can we 'hide' from them? How?
-   What does `Proc#to_unbound_method` look like? Does it need to take an argument?