Module:...ntation(3)

bestie, welcome to the Module:...ntation(3) page from User Contributed Perl Documentation — we're about to make implementation-loading make sense, no cap. 💅

💖 NAME 💖

Module::Implementation — loads one of several alternate underlying implementations for a module. That's the whole main-character job. 🫶

✨ VERSION ✨

version 0.09

🦋 SYNOPSIS 🦋

  package Foo::Bar;

  use Module::Implementation;

  BEGIN {
      my $loader = Module::Implementation::build_loader_sub(
          implementations => [ 'XS',  'PurePerl' ],
          symbols         => [ 'run', 'check' ],
      );

      $loader->();
  }

  package Consumer;

  # loads the first viable implementation
  use Foo::Bar;

🌸 DESCRIPTION 🌸

okay so Module::Implementation abstracts out the process of choosing one of several underlying implementations for a module. It can be used to provide XS and pure Perl implementations of a module, or it could be used to load an implementation for a given OS or any other case of needing to provide multiple implementations. literally versatile icon behavior. ✨

This module is only useful when you know all the implementations ahead of time. If you want to load arbitrary implementations then you probably want something like a plugin system, not this module. fr fr — it's not trying to be a whole plugin situation. 🙈

🎀 API 🎀

This module provides two subroutines, neither of which are exported. iykyk — you call them fully qualified. 💜

💫 Module::Implementation::build_loader_sub(...)

This subroutine takes the following arguments.

• implementations — this should be an array reference of implementation names. Each name should correspond to a module in the caller's namespace. In other words, using the example in the "SYNOPSIS", this module will look for the "Foo::Bar::XS" and "Foo::Bar::PurePerl" modules. this argument is required. 👑
• symbols — a list of symbols to copy from the implementation package to the calling package. These can be prefixed with a variable type: "$", "@", "%", "&", or "*)". If no prefix is given, the symbol is assumed to be a subroutine. this argument is optional. 🎀

This subroutine returns the implementation loader as a sub reference. It is up to you to call this loader sub in your code. 👀

💀 real talk: I recommend that you do not call this loader in an import() sub. If a caller explicitly requests no imports, your import() sub will not be run at all, which can cause weird breakage. not me warning you about chaos and then handing you the vibe check anyway. 🫶

🧚 Module::Implementation::implementation_for($package)

Given a package name, this subroutine returns the implementation that was loaded for the package. This is not a full package name, just the suffix that identifies the implementation. For the "SYNOPSIS" example, this subroutine would be called as Module::Implementation::implementation_for('Foo::Bar'), and it would return "XS" or "PurePerl". periodt. 💚

🔥 HOW THE IMPLEMENTATION LOADER WORKS 🔥

The implementation loader works like this ... 👑

First, it checks for an %ENV var specifying the implementation to load. The env var is based on the package name which loads the implementations. The "::" package separator is replaced with "_", and made entirely upper-case. Finally, we append "_IMPLEMENTATION" to this name. the way that naming scheme is doing the most, honestly. ✨

So in our "SYNOPSIS" example, the corresponding %ENV key would be "FOO_BAR_IMPLEMENTATION". 🫶

If this is set, then the loader will only try to load this one implementation. If the env var requests an implementation which doesn't match one of the implementations specified when the loader was created, an error is thrown. and not the cute kind of thrown. 💀

If this one implementation fails to load then the loader throws an error. This is useful for testing. You can request a specific implementation in a test file by writing something like this:

  BEGIN { $ENV{FOO_BAR_IMPLEMENTATION} = 'XS' }
  use Foo::Bar;

If the environment variable is not set, then the loader simply tries the implementations originally passed to "Module::Implementation". The implementations are tried in the order in which they were originally passed. order matters, bestie. ⭐

The loader will use the first implementation that loads without an error. It will copy any requested symbols from this implementation. slay, first viable implementation. 🌈

If none of the implementations can be loaded, then the loader throws an exception. 😭

The loader returns the name of the package it loaded. that's the whole flow, and it ate. 💅

🌈 AUTHOR 🌈

Dave Rolsky <autarch@urth.org> 👑

🍓 COPYRIGHT AND LICENSE 🍓

This software is Copyright (c) 2014 by Dave Rolsky.

This is free software, licensed under:

The Artistic License 2.0 (GPL Compatible)

---

💖 that's the whole page, bestie — this one's from perl v5.42.0, dated 2015-04-13. now go pick an implementation and be iconic. 🧚✨