Can anyone construct two proc objects p1 and p2, without using clone or 
dup, so that p1==p2 but p1.object_id != p2.object_id?

I thought this code would do it, but it does not:

def blah
   Proc.new  # return block as a proc
end
pr1 = Proc.new { |x| x*x }
pr2 = blah(&pr1)
puts pr1==pr2                        # true
puts pr1.object_id == pr2.object_id  # true, so they're the same object

Unless I'm missing something here, I think the documentation for Proc.== 
is misleading.  It says:

   Return +true+ if _prc_ is the same object as _other_proc_, or if
      they are both procs with the same body.

Based on this, I would think that:

   lambda {|x| x*x } == lambda {|x| x*x }

But this expression return false in both ruby 1.8 and 1.9.

So anyway, unless I'm missing some obvious way to construct two procs 
"with the same body" I think the documentation should be clarified.  I 
suggest something like:

   Return true if prc is the same object as other_proc, or if one is a
   clone or duplicate of another.  Two procs created from distinct blocks
   are not equal, even if those blocks have identical source code.

     David Flanagan