What's the correct way to deal with multiple inheritence of modules sharing a common "ancestor" in Perl?

Your new class effectively looks like this:

package MyUA;

use parent qw(LWP::RobotUA LWP::UserAgent::Determined);

1;

Let's test it like this:

#!/usr/bin/perl

use strict;
use warnings;
use feature 'say';

use MyUA;

my $ua = MyUA->new(
  agent => 'test',
  from  => 'me@example.com',
);

say ref $ua;

That tells us that we have "MyUA" object. But what is it really? What have we made?

Well, objects are build using a constructor method. That's (usually) called new(). In this case, you haven't defined a new() method in your class. So Perl will look for the method in the superclasses. It does that by searching the classes it finds in @INC and seeing if each one, in turn, contains a new() method.

Both of your superclasses have a new() method. But Perl only needs one. So when it finds one, it stops looking and calls that method. The first one it calls is the one in LWP::RobotUA (because that's the first one on the list passed to use parent). So that one gets called.

This means that what you've actually got here is an object of class LWP::RobotUA. Well, mostly. It's been blessed into the right class and if you call any methods that are in LWP::UserAgent::Determined, but not in LWP::RobotUA, it will still work. But none of the LWP::UserAgent::Determined initialisation code has been called.

And that's a pretty good demonstration of why multiple inheritance is a bad idea. It's so hard to get it right in all but the most trivial of cases.

I can't give you an answer here. Because only you know which bits of the two superclasses you need. But the solution will involve adding your own new() method to your class and probably calling the two superclass constructors from within that.

Update: Ok, I've had a closer look. And it might be easier than I thought.

LWP::RobotUA::new() makes a call to LWP::UserAgent::new() in the middle of doing various other things. But LWP::UserAgent::Determined::new() makes a call to LWP::UserAgent::new() at the start of its processing and then helpfully bundles all of its other initialisation up in a separate method called _determined_init().

So it looks like your solution could be a simple as adding a constructor method like this:

sub new {
  my $class = shift;
  my $self = $class->SUPER::new(@_);
  $self->_determined_init();

  return $self;
}

The call to $class->SUPER::new() calls LWP::RobotUA::new() because that's the first class in @INC. That, in turn, calls LWP::UserAgent::new() - so that initialisation is all done. We then just have to call _determined_init() in order to initialise the other superclass.

It seems to work in my (very basic) testing. But I'm still very dubious about multiple inheritance :-)

Update 2: Yes. ikegami is right. My solution only fixes the problems with constructing the object. I didn't look into actually using it.

That can't work without changes to LWP::UA::Determined and/or LWP::RobotUA.

But those changes can be applied through monkey patching. A solution is presented at the bottom.

The Problem

LWP::UA::Determined wraps ->simple_request, which is to say it provides a ->simple_request which calls ->SUPER::simple_request (which is ->LWP::UA::simple_request)

LWP::RobotUA wraps ->simple_request, which is to say it provides a ->simple_request which calls ->SUPER::simple_request (which is ->LWP::UA::simple_request)

When you call ->request, you'll end up calling ->simple_request. Depending on the order of the modules in @ISA, this will call either LWP::UA::Determined::simple_request (and then LWP::UA::simple_request) or LWP::RobotUA::simple_request (and then LWP::UA::simple_request).

It will not call both LWP::UA::Determined::simple_request and LWP::RobotUA::simple_request. And it wouldn't work if it did because that would end up calling LWP::UA::simple_request twice.

The exact same problem exists for ->new.

Demo

use feature qw( say );

{ package Base;
  sub method { say __PACKAGE__; } }

{ package SubA; our @ISA = qw( Base ); 
  sub method { say __PACKAGE__; $_[0]->SUPER::method(); } }

{ package SubB; our @ISA = qw( Base ); 
  sub method { say __PACKAGE__; $_[0]->SUPER::method(); } }

{ package SubAB; our @ISA = qw( SubA SubB ); }

SubAB->method();  # SubA Base

The Solution

LWP::UA::Determined and LWP::RobotUA would need to use next::method instead of SUPER (or they would need to be designed entirely differently) for this to even have a chance of working.

Demo

use feature qw( say );

{ package Base;
  sub method { say __PACKAGE__; } }

{ package SubA; use mro 'c3'; our @ISA = qw( Base );
  sub method { say __PACKAGE__; $_[0]->next::method(); } }

{ package SubB; use mro 'c3'; our @ISA = qw( Base );
  sub method { say __PACKAGE__; $_[0]->next::method(); } }

{ package SubAB; use mro 'c3'; our @ISA = qw( SubA SubB ); }

SubAB->method();  # SubA SubB Base

The Workaround

All hope isn't lost! We can monkey patch LWP::UA::Determined and LWP::RobotUA to get the desired behaviour!

Simply add this to your program:

use LWP::RobotUA qw( );
BEGIN {
   package LWP::RobotUA::Inserted;
   use mro 'c3';
   our @ISA = @LWP::RobotUA::ISA;
   sub new            { return $_[0]->next::method(); }
   sub simple_request { return $_[0]->next::method(); }
   sub agent          { return $_[0]->next::method(); }
   @LWP::RobotUA::ISA = __PACKAGE__;
}

use LWP::UserAgent::Determined qw( );
BEGIN {
   package LWP::UserAgent::Determined::Inserted;
   use mro 'c3';
   our @ISA = @LWP::UserAgent::Determined::ISA;
   sub new            { return $_[0]->next::method(); }
   sub simple_request { return $_[0]->next::method(); }
   @LWP::UserAgent::Determined::ISA = __PACKAGE__;
}

You also need use mro 'c3'; in your own class (or choose the order of @ISA carefully) for ->agent to work correctly.

Demo

# Insert code from first demo here.

{ package SubA::Inserted; use mro 'c3'; our @ISA = @SubA::ISA;
  sub method { return $_[0]->next::method(); }
  @SubA::ISA = __PACKAGE__; }

{ package SubB::Inserted; use mro 'c3'; our @ISA = @SubB::ISA;
  sub method { return $_[0]->next::method(); }
  @SubB::ISA = __PACKAGE__; }

SubAB->method();  # SubA SubB Base