package MyPragma;

use base qw(Method::Lexical);

sub import {
    shift->SUPER::import(
        'private'         => sub { ... },
        'UNIVERSAL::dump' => '+Data::Dump::pp'
    )
}

#!/usr/bin/env perl

my $self = bless {};

{
    use MyPragma;

    $self->private(); # OK
    $self->dump();    # OK
}

$self->private; # Can't locate object method "private" via package "main"
$self->dump;    # Can't locate object method "dump" via package "main"

use Method::Lexical {
    foo              => \&foo,               # unqualified method-name key: installed in the currently-compiling package e.g. main::foo
    MyClass::foo     => \&foo,               # qualified method-name key: installed in the specified package
    bar              => sub { ... },         # anonymous sub value
    baz              => \&baz,               # coderef value
    quux             => 'main::quux',        # sub name value: unqualified names are resolved to the currently-compiling package
    dump             => '+Data::Dump::dump', # autoload Data::Dump
   'UNIVERSAL::dump' => \&Data::Dump::dump,  # define a universal method
   'UNIVERSAL::isa'  => \&my_isa,            # override a universal method
  '-autoload'        => 1,                   # autoload modules for all subs passed by name
  '-debug'           => 1                    # show diagnostic messages
};

use Method::Lexical {
     foo       => 'MyFoo::foo',
     bar       => 'MyBar::bar',
     baz       => 'MyBaz::baz',
   '-autoload' => 1,
};

use MyFoo;
use MyBaz;

use Method::Lexical {
     foo =>  'MyFoo::foo',
     bar => '+MyBar::bar', # autoload MyBar
     baz =>  'MyBaz::baz',
};

use Method::Lexical {
    AUTOLOAD             => sub { ... },
   'UNIVERSAL::AUTOLOAD' => \&autoload,
};

use Method::Lexical {
     foo    => \&foo,
     bar    => sub { ... },
   '-debug' => 1
};

package Universal::Dump;

use base qw(Method::Lexical);

sub import { shift->SUPER::import('UNIVERSAL::dump' => '+Data::Dump::dump') }

1;

#!/usr/bin/env perl

use CGI;

{
    use Universal::Dump;

    say CGI->new->dump; # OK
}

eval { CGI->new->dump };
warn $@; # Can't locate object method "dump" via package "CGI"

use Method::Lexical foo => \&foo;

my $self = bless {};

{
    use Method::Lexical {
         bar             => sub { ... },
        'UNIVERSAL::baz' => sub { ... },
    };

    $self->foo(); # OK
    $self->bar(); # OK
    $self->baz(); # OK

    no Method::Lexical qw(foo);

    eval { $self->foo() };
    warn $@; # Can't locate object method "foo" via package "main"

    $self->bar(); # OK
    $self->baz(); # OK

    no Method::Lexical;

    eval { $self->bar() };
    warn $@; # Can't locate object method "bar" via package "main"

    eval { $self->baz() };
    warn $@; # Can't locate object method "baz" via package "main"
}

$self->foo(); # OK

{
    use MyPragma qw(foo bar baz);

    use Method::Lexical quux => \&quux;

    $self->foo();  # OK
    $self->quux(); # OK

    no MyPragma qw(foo); # unimports foo
    no MyPragma;         # unimports bar and baz
    no Method::Lexical;  # unimports quux
}

sub public {
    my $self = shift;
    $self->private(); # not a private method; compiled as an ordinary (public) method call
}

use Method::Lexical private => sub { ... };

use Method::Lexical private => sub { ... };

sub public {
    my $self = shift;
    $self->private(); # OK
}