I was thinking bout examples which do "similar" things, and Term::ReadLine or JSON come to mind, which can switch between different backends.

My (maybe naive) approach would be to have a 2 modules for the start, a default implementation Foo::Bar::Standard for fall back and a façade Foo::Bar which exports the API functions which call those standard implementation functions.

Something like use Foo::Bar "Other"; would first import the functions of Foo::Bar::Other into package Foo::Bar instead of those from Standard before exporting the interface.

Another approach to access the implementation from Foo::Bar is of course to manipulate @ISA. The interface functions would access the implementation by inheritance.

I'm sure there are even more OOP patterns to do this and curious to read more replies.

update

Your mention of h2xs is puzzling me. Are you talking about C implementations?

Yes it’s rather abstract because I’m looking for general solution. I think what I’d like to do is something similar to java collection. List is an interface and there are multiple concrete implementations. So I might have pure perl and xs backend implementations. I just remember there’re some Perl modules if xs is available it’ll use xs backend implementation otherwise using pure perl.

Update

Design pattern wise, I am thinking of abstract factory pattern. There’ will be factory, products interfaces and of course actual concrete implementations.

> I’m looking for general solution

Sorry, this sounds like you are looking for a way to do Java in Perl. Many answers in the Java world don't apply to Perl because the questions don't arise.

And it's not clear for me HOW the implementation should be chosen. automatically or by users choice.

> List is an interface and there are multiple concrete implementations.

Not an issue in Perl because it doesn't have static typing of the list elements.

> I think what I’d like to do ...

Please think harder what you want and show some Perl code exemplifying it.

Most of us don't "speak" Java... ;-)

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Wikisyntax for the Monastery}

There's Java's collections as an example where interface List could represent an AbstractList, AbstractSequentialList, ArrayList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector, or something else that implements what a list does, add(), and remove() and whatever else.

Tree::Binary uses Visitor_pattern to separate interface and implementation. You have Visitor::BreadFirstTraversal and Visitor::InOrderTraversal. Both are called with the visit method.

You could just pass in a sub reference to your interface containing the implementation.

#!/usr/bin/env perl
use strict;
use warnings;
use feature 'say';

sub multiply {
    my ( $x, $y, $implementation ) = @_;
    $implementation->( $x, $y );
}

sub whateverthedefaultis {
    my ( $x, $y ) = @_;
    return $x * $y;
}

# https://blogs.msdn.microsoft.com/matthew_van_eerde/2009/07/23/bad-pe
+rl-russian-peasant-multiplication-algorithm/

sub peasant {
    my ( $a, $b ) = @_;
    my $c;
    map { $c += $_ * $b }
      grep { $a & $_ }
      map { 1 << $_ } ( 0 .. log($a) / log 2 );
    return $c;
}

say multiply( 7, 3, \&whateverthedefaultis );
say multiply( 7, 3, \&peasant );
[download]

Thanks! this is helpful. I'm familiar with File::Spec. Indeed there are different underlying implementations for different OSes.

"...Does that mean one developer will be writing his/her own ... Foo::Bar::Implementation?"

I skip the h2xs part because of no clue. Anyway: He/she might think of it (the implementation ) as a kind of plugin. A very simple example - but i think it shows the basic idea. Some say Perl is different. A anon monk linked already to roles...

Best regards, Karl