exussum0 asked in the chatterbox whether there's a quick way to wrap the methods of an object such that you can access them as plain functions which are exported to a package. Thus, here's my solution.

Take this module:

package Wrapobj;
our $VERSION = 1.000;
use Scalar::Util "blessed";
use mro;
sub import {
    my $en = caller;
    my $ens = $en . "::";
    my $ep = \%{(do { no strict "refs"; $ens })};
    my($_u, $o) = @_;
    my $c = blessed($o) || $o;
    for my $n (@{mro::get_linear_isa($c)}) {
        my $p = \%{(do { no strict "refs"; $n . "::" })};
        for my $s (sort keys %$p) {
            if (exists(&{$$p{$s}})) {
                if (!$$ep{$s} || !exists(&{$$ep{$s}})) {
                    *{$ens . $s} = sub { $o->${\$s}(@_) };
                }
            }
        }
    }
}
1;
__END__
[download]

Now you can import the methods of an object $obj by saying use Wrapobj $obj;. For example, you could say

use Math::BigInt; use Wrapobj Math::BigInt->new("100"); warn bmul(2); 
+warn as_hex()
[download]

You could even use this on a class to access class methods:

use Math::BigInt; use Wrapobj Math::BigInt::; warn new("0x100");
[download]

Of course, this is just a proof of concept module, a real one would allow you to explicitly set which subs you want to import, and frankly, you likely don't want to use this kind of thing in real code anyway.

(See also Foo::Simple.)