Here's a naïve implementation:

package Foo;
use UtilityClass;

sub some_method {
    my $self = shift;
    $self->UtilityClass::some_method(@_);
}
[download]

package Foo;
use UtilityClass;

sub helper_class { 'UtilityClass' };

sub some_method {
    goto &{ $_[0]->helper_class->can('some_method') };
}
[download]

I didn't see any mention of proxying methods off to this other class. I interpreted the question as one of how to share some common functionality, not how to pass method calls off to a different class.

Since we're doing OO and therefore concerned about inheritance and such, the utility class should be an actual class and use class methods:

package Foo;
use UtilityClass;

sub bubbles {
    ...class-specific stuff...
    UtilityClass->buttercup();
    ...class-specific stuff...
}
[download]

The problem there is that you've hardwired the Utility class's name into your class. Suppose you want to subclass Foo to use a different UtilityClass (or a subclass of it), with the hardwiring you have in place you have to override all the methods that make calls to the utility class.

At the very least you should wrap the Utility classname in a method, so your code becomes:

package Foo;
use UtilityClass;

sub helper { 'UtilityClass' }

sub bubbles {
   ...
   $self->helper->buttercup();
   ...
}
[download]

Et voila! you'll only have to change the utility class name at two points in your subclass; no need to override.

Actually, I wonder if you couldn't use the Exporter to implement something like a ruby mixin.

package UtilityClass;

use base 'Exporter';

@EXPORT = qw/buttercup/;

sub buttercup {
   my $self = shift; # $self is *not* a 'UtilityClass';
   ...
}
[download]

You know, I'm not sure whether that's a good idea, or a barking mad one...