As I said, if we take it to it's extreme we can't require anything, and that's ridiculous.  I see a few dimensions to this:

* How useful is the stdlib library?  The more useful it is to use, the more I'm OK with us loading it.
* How easy would it be to hand roll ourselves?  If we can get the same functionality with a few lines of our own code I'm less likely to be OK with us loading it.
* How commonly used is the stdlib library?  I'm more OK with us loading a rarely-used lib both because fewer users are likely to also be using it (and thus fewer possibilities of running into the using-without-requiring-but-test-pass issue) and because it's more likely that users will remember to require it (in contrast, consider a case like `Time`: there are some methods that are only made available by `require 'time'`, but `Time` is always available as a constant, so it's easy to forget).

In this case, I would recommend doing this:

``` ruby
class Procsy
  # The `metadata` of the {Example} instance.
  attr_reader :metadata

  def initialize(metadata, &block)
    @metadata = metadata
    @proc = block
  end

  Proc.public_instance_methods(false).each do |name|
    define_method(name) { |*a, &b| @proc.__send__(name, *a, &b) }
  end
  alias run call

private

  def to_proc
    @proc
  end
end
```

* It's about the same number of lines of code as the `Forwardable` solution and isn't much more complex.
* It takes care of making the full public API of `Proc` available, w/o needing to resort to `method_missing` and the baggage that entails.