/ 
Evo-0.0253
River stage one • 1 direct dependent • 1 total dependent
/ Evo::Export

NAME

Evo::Export

VERSION

version 0.0253

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.