++ed by:
AERO MAMOD ALEXBYK

3 PAUSE users
2 non-PAUSE users.

Alexbyk
and 1 contributors

NAME

Evo::Export

VERSION

version 0.0405

DESCRIPTION

Standart Exporter wasn't good enough for me, so I've written a new one from the scratch

SYNOPSYS

  package My::Lib;
  use Evo '-Export *', -Loaded;

  # export foo, other as bar
  sub foo : Export        { say 'foo' }
  sub other : Export(bar) { say 'bar' }

  # test.pl
  package main;
  use Evo 'My::Lib *';
  foo();
  bar();

IMPORTING

  use Evo;
  use Evo 'Evo::Eval eval_try';
  use Evo '-Promise promise deferred';

For convenient, you can load all above in one line (divide by , or ;)

  use Evo '-Eval eval_try; -Promise promise deferred';
  use Evo '-Eval eval_try, -Promise promise deferred';

* means load all. - is a shortcut. See ""shortcuts" in Evo

what to import and how

You can rename subroutines to avoid method clashing

  # import promise as prm
  use Evo '-Promise promise:prm';

You can use * with exclude - for convinient, use whitespace as a delimiter

  # import all except "deferred"
  use Evo '-Promise * -deferred';

If one name clashes with yours, you can import all except that name and import renamed version of that name

  # import all as is but only deferred will be renamed to "renamed_deferred"
  use Evo '-Promise * -deferred deferred:renamed_deferred';

EXPORTING

Firstly you need to load Evo::Export with import (or *). This will import import method:

  use Evo '-Export *';
  use Evo '-Export import';

By default, use Your::Module;, without arguments will import nothing. You can change this behaviour to export all without arguments

  use Evo '-Export import_all:import';
  use Evo '-Export * -import import_all:import';

Using attribute Export

  package My::Lib;
  use Evo '-Export *'; # or use Evo::Export 'import';
  use Evo -Loaded;

  sub foo : Export { say 'foo' }

  package main;
  use Evo 'My::Lib foo';
  foo();

Pay attention that module should either import import, or call Evo::Export/install directly (see example below) from import method

You can export with another name

  # export as bar
  sub foo : Export(bar) {say 'foo'}

(EXPERIMENTAL) Using attribte ExportGen

  package My::Lib;
  use Evo '-Export *; -Loaded';

  sub bar ($me, $dest) : ExportGen {
    say qq{"$dest" requested "bar" exported by "$me"};
    return sub { say "$me-$dest-bar" };
  }

  package main;
  use Evo;
  My::Lib->import('*');
  bar();

INSTALLING DIRECTLY

If you want to write your own import method, do it this way:

  package My::Lib;
  use Evo -Export;    # don't import "import"
  use Evo -Loaded;

  sub import ($self, @list) {
    my $dest = scalar caller;
    Evo::Export->install_in($dest, $self, @list ? @list : ('*'));    # force to install all
  }
  sub foo : Export { say 'foo' }


  package main;
  use Evo 'My::Lib';
  foo();

export;

Export signature is more preffered way, but if you wish

  # export foo
  export 'foo';

  # export "foo" under name "bar"
  export 'foo:bar';

Trying to export not existing subroitine will cause an exception

export_code

Export function, that won't be available in the source class

  # My::Lib now exports foo, but My::Lib::foo doesn't exist
  export_code foo => sub { say "hello" };

export_proxy

  # reexport all from My::Other
  export_proxy 'My::Other', '*';


  # reexport "foo" from My::Other
  export_proxy 'My::Other', 'foo';

  # reexport "foo" from My::Other as "bar"
  export_proxy 'My::Other', 'foo:bar';

export_gen (EXPERIMENTAL)

  package My::Lib;
  use Evo '-Export *; -Loaded';

  export_gen foo => sub ($me, $dest) {
    say qq{"$dest" requested "foo" exported by "$me"};
    sub {say "hello, $dest"};
  };


  package main;
  use Evo;
  My::Lib->import('*');
  foo();

Very powefull and most exciting feature. Evo::Export exports generators, that produces subroutines. Consider it as a 3nd dimension in 3d programming. Better using with ExportGen attribute

EXPORT

This method returns a bound instance of Evo::Export::Meta, which is stored in package's $EVO_EXPORT_META variable. Also a cache for generated export is stored in class'es $EVO_EXPORT_CACHE variable

  use Evo;
  {

    package My::Lib;
    use Evo '-Export *', -Loaded;
    sub foo : Export { }

    sub bar : ExportGen {
      sub { }
    }

    package My::Dest;
    use My::Lib '*';
  }

  use Data::Dumper;
  say Dumper (My::Lib->EXPORT->info);
  say Dumper ($My::Lib::EVO_EXPORT_META->info);
  say "cache of My::Dest: ", Dumper($My::Dest::EVO_EXPORT_CACHE);

import

By default, this method will be exported and do the stuff. If you need replace import of your module, exclude it by use Evo '-Export * -import'

AUTHOR

alexbyk.com

COPYRIGHT AND LICENSE

This software is copyright (c) 2016 by alexbyk.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.