Furl is implemented as a reference to a reference, not as a reference to a hash. This makes adding fields to it a bit harder.

The easier way would be to delegate to it instead of inheriting from Furl:

package XYZ;
use strict; use warnings;
our $VERSION = 1;
use parent 'Furl';
sub new {
 my $class = $_[0];
 my $furl = Furl->new();
 my $self = {
    furl => $furl,
 };
 bless($self, $class); # rebless to our own class
 # setting some own data in self:
 $self->{'debug'} = 1;
 $self->{'ABC'} = 42;
 return $self
}
[download]

This of course means that you will need to implement all "inherited" methods from Furl as stubs in your class:

for my $method (qw(get put whatever)) {
    *$method = sub { my $self = shift; $self->{furl}->$method( @_ ); }
};
[download]

This of course means that you will need to implement all "inherited" methods from Furl as stubs in your class:

please no! Any way to access that "reference to a reference"?

Basically, what I am looking for is a fast equivalent to LWP::UserAgent which also allows for adding handlers. (I am not sure Furl offers handlers but it was just an experiment). Curl obviously comes to mind. But I did not find it dramatically faster than LWP. Whereas Furl was dramatically faster. What's your experience? The situation is 15,20 hits per minute. More than speed is the CPU load as it will be on a rented host.

This is NOT a good idea (Breaks encapsulation) .. but it could work for a POC for this case:

  $$self->{MyAdditionToFURL}= "MyValue";
  #<< Extra "$" here, to access the extra indirection used by 'furl'
[download]

(UNTESTED)

                As a computer, I find your faith in technology amusing.

You might be interested in MooX::InsideOut: "This is useful for extending non-Moo classes whose internals you don't want to change, or which aren't hash based."

Other than that, there are several other InsideOut classes on CPAN, and in the core there is Hash::Util::FieldHash, but I've never used the latter so I can't say if it's a good idea to use.

Thanks for the references. It's comforting to know that my problem is more widespread though I still struggle to understand the Inside-Out technique.

bliako:

You've already gotten some answers, but after reading your question, and seeing Corion's suggestion, it made me think a bit. So just for amusement, I cobbled something together. I'm not saying you should use it, it's more of an amusing experiment that might suggest to you other avenues to explore.

I've not used the AUTOLOAD feature often, but I find it interesting, so I thought I'd whip up an experiment that will handle the case you call out: where you want to subclass a thing not based on a hashref.

$ cat pm_autodelegate.pl
#!env perl

{ # A package based on a reference to something other than a hash
    package a_scalar_thing;

    sub new {
        my $class = shift;
        my $a = 99;
        return bless \$a, $class;
    }

    sub a { return 42; }
    sub b { return $_[1]*5; }
}

{ # A package that you want to augment without munging around in
  # it's innards
    package auto_delegate;

    sub new {
        my $class = shift;
        my $delegate = a_scalar_thing->new();
        return bless { delegate=>$delegate }, $class;
    }

    sub a { return '*'; }
    sub c { return 'D'; }

    # auto_delegate doesn't do the expected action, so try to
    # delegate it to the original thing
    sub AUTOLOAD {
        my $self = shift;
        my $func = $auto_delegate::AUTOLOAD;
        $func =~ s/.*:://;
        if ($self->{delegate}->can($func)) {
            $self->{delegate}->$func(@_);
        }
        else {
            print "auto_delegate: Dunno how to '$func'\n";
        }
    }

    # Since we have AUTOLOAD, we need DESTROY or we'll get a
    # 'Dunno how to' message.  We explicitly delete the delegate to
    # ensure it's collected--probably unnecessary, but harmless
    sub DESTROY {
        delete $_[0]{delegate};
    }

    # AUTOLOAD docs indicate that overriding can() is probably
    # also a good idea.  I didn't bother for this experiment...
}

my $orig = a_scalar_thing->new(tense=>0);

print "orig: a:", $orig->a(), ", b(10):", $orig->b(10), "\n";

my $dele = auto_delegate->new(tense=>99, loose=>0);
print "dele: a:", $dele->a(), ", b(10):", $dele->b(10), ", c:", $dele-
+>c(), "\n";

print "dele: unknown_func:", $dele->unknown_func(66), "\n";


Roboticus@Waubli ~
$ perl pm_autodelegate.pl
orig: a:42, b(10):50
dele: a:*, b(10):50, c:D
auto_delegate: Dunno how to 'unknown_func'
dele: unknown_func:1
[download]

It works as it is, but if you wanted to use something like it, you'll want to improve it. For example, in the AUTOLOAD sub, I do a lookup every time we need to do something not provided by auto_delegate. Corions solution explicitly patches the symbol table so the method invocations are faster. You could patch it on demand for better performance, if you want. You would also want to review the relevent documentation (notably perlsub and perlobj), figure out how you want to handle calling the superclass methods when needed, test the heck out of it to make it bulletproof.

For your case, I prefer Corion's solution, but I really wanted to play with AUTOLOAD for a little bit this morning.

# I didn't test this, and didn't throw it away for some reason...
package a_delegate;

BEGIN {
    # If you don't like AUTOLOAD you could also use Corions solution, 
+but use a blacklist
    # instead of a whitelist, to ensure that you capture new superclas
+s methods if any arise.
    my %IGNORE = map { $_=>undef } qw( new and other funcs to ignore d
+elegation );

    for my $method (keys %Furl::) {
        next if exists $IGNORE{$method};
        die "a_delegate already provides an implementation of $method!
+\n"
           if exists $a_delegate::{$method};

        *$method = sub { my $self=shift; $self->{delegate}->$method(@_
+); };
    }

    # Your normally scheduled package stuff...
}
[download]

I hope you find this amusing.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

I get it thanks. Can't say I find it amusing ;) but hey!

So, I learned that unresolved subs go through AUTOLOAD if defined. That has shed light to an area I kept postponing to read about. AUTOLOAD!

In your last chunk you mention keys %Furl::, wouldn't that include variables?

bliako:

Yeah, I expect that'll also pick up our variables in the package. I wasn't really thinking about those, as I mostly use my variables. I guess it would pick up other things, too. I guess you'd have to add a check to verify that it's a code thing before deciding to build the method.

...roboticus

When your only tool is a hammer, all problems look like your thumb.