Test: cat t/01-use.t

package __test__;

use v5.22;
use warnings;

use Test::More;
use lib "../lib";

sub dummy {}

{
    my $line = __LINE__;
    use lexical 'Scalar::Util' => qw/looks_like_number/;
    is(__LINE__, $line+2, "line numbers are not messed up ");

    is( defined(&looks_like_number) ,1 ,"sub exists");
    is( looks_like_number("42"), 1, "42 is number" );
    isnt( looks_like_number("XX"), 1, "XX isn't number" );

    is(defined  &__test__::dummy, 1, "namespace testable");
    isnt( defined(&__test__::looks_like_number) ,1 ,"namespace is clea
+n");
}

isnt( defined(&looks_like_number) ,1 ,"lex sub doesn't exist out of sc
+ope");

diag( "Testing lexical $lexical::VERSION, Perl $], $^X" );

done_testing;
[download]

test run

 
perl /home/lanx/perl/prj/lexical/t/01-use.t
ok 1 - line numbers are not messed up 
ok 2 - sub exists
ok 3 - 42 is number
ok 4 - XX isn't number
ok 5 - namespace testable
ok 6 - namespace is clean
ok 7 - lex sub doesn't exist out of scope
# Testing lexical 0.01, Perl 5.038002, /usr/bin/perl
1..7
[download]

Module: cat lib/lexical.pm

package lexical;

use v5.22;
use strict;
use warnings;
use Filter::Util::Call ;

=head1 NAME

lexical - Lexical use of exported functions

=head1 VERSION

Version 0.01

=cut

our $VERSION = '0.01';


=head1 SYNOPSIS

Pragma to import subs as lexical_subs into the current scope

    use lexical "Scalar::Util" => qw/looks_like_number/;

    print looks_like_number("a15");


=head1 EXPORT

No classic exports, the namespace isn't polluted

=head1 SUBROUTINES/METHODS

=head2 import

=cut

sub import {
    my ($my_pkg, $module, @imports) = @_;

    eval "use $module";                   # TODO quick & dirty

    my $code = q(use experimental 'lexical_subs','refaliasing';);

    $code .= << "__CODE__" for @imports;   # TODO only subs ATM
my sub $_;
\\&$_ = \\&${module}::$_;
__CODE__

    upject($code);

}


sub upject {
   my $injection  = shift;

   # --- exit if undef
   return unless defined $injection;

   # --- adjust line number to disguise injection
   my ($file,$line) = (caller(2))[1,2];
   $line++;
   $injection .= qq{\n# line $line "$file"\n};

   #warn $injection;
   
   # --- add source filter
   filter_add
     (
      sub {
         my $status =
           filter_read_exact(1);        # read one char into $_
         if ( $status  > 0) {
            $_ = $injection .";".$_;    # prepend code once
            filter_del();               # delete source filter
         }
         $status ;
      }

     );


}

=head1 AUTHOR

Rolf Michael Langsdorf, C<< <lanx at cpan.org> >>

# yadda yadda ...

1; # End of lexical
[download]

Bingo!

my sub $_;
\\&$_ = \\&${module}::$_;
[download]

This is what I was looking for. And you've packaged it nicely in an importer, too.

This project does much more than you want, it's realizing macros (well almost) with a use macro() syntax at compile time.

See my presentation from 2019 in Riga: https://perlcon.eu/talk/97

> Where does the injection take place?

Basically is the import() using a source-filter to inject code into the line after the use .

When using that pseudo-module an INC-hook looks for the macro-function.

If you come up with a reasonable name (I already kind of burned Filter::Inject ;) I could publish a module to CPAN doing lexical-imports by wrapping the original module.

use Scoped "MODULE" => ARGUMENTS; ¹

possible names:

• Scoped
• Lexically
• My::Use
• My::Import
• Mine

I'm also not sure if this should rather be lower-cased to indicate a pragma²

¹) in your case:

use lexical Scalar::Util => qw/looks_like_number/;

²) I think lower-case is reasonable here, since if is a pragma too.