add import_into

[p5sagit/Function-Parameters.git] / lib / Function / Parameters.pm

diff --git a/lib/Function/Parameters.pm b/lib/Function/Parameters.pm
index 6d5a148..9108695 100644 (file)
--- a/lib/Function/Parameters.pm
+++ b/lib/Function/Parameters.pm
@@ -27,18 +27,39 @@ sub guess_caller {
 
 sub _fun ($) { $_[0] }
 
-sub import {
-       my $class = shift;
-       my $caller = guess_caller;
-       #warn "caller = $caller";
+sub _croak {
+       require Carp;
+       {
+               no warnings qw(redefine);
+               *_croak = \&Carp::croak;
+       }
+       goto &Carp::croak;
+}
+
+sub import_into {
+       my $victim = shift;
+       my $keyword = @_ ? shift : 'fun';
+       
+       _croak qq["$_" is not exported by the ${\__PACKAGE__} module] for @_;
+
+       $keyword =~ /^[[:alpha:]_]\w*\z/ or _croak qq{"$keyword" does not look like a valid identifier};
 
        Devel::Declare->setup_for(
-               $caller,
-               { fun => { const => \&parser } }
+               $victim,
+               { $keyword => { const => \&parser } }
        );
 
        no strict 'refs';
-       *{$caller . '::fun'} = \&_fun;
+       *{$victim . '::' . $keyword} = \&_fun;
+}
+
+sub import {
+       my $class = shift;
+       
+       my $caller = guess_caller;
+       #warn "caller = $caller";
+
+       import_into $caller, @_;
 }
 
 sub report_pos {
@@ -254,6 +275,9 @@ Function::Parameters - subroutine definitions with parameter lists
  
  print "$_\n" for mymap { $_ * 2 } 1 .. 4;
 
+ use Function::Parameters 'proc';
+ my $f = proc ($x) { $x * 2 };
+ 
 =head1 DESCRIPTION
 
 This module lets you use parameter lists in your subroutines. Thanks to
@@ -278,6 +302,10 @@ copied into C<my> and initialized from L<@_|perlvar/"@_">.
 
 =head2 Advanced stuff
 
+You can change the name of the new keyword from C<fun> to anything you want by
+specifying it in the import list, i.e. C<use Function::Parameters 'spork'> lets
+you write C<spork> instead of C<fun>.
+
 If you need L<subroutine attributes|perlsub/"Subroutine Attributes">, you can
 put them after the parameter list with their usual syntax. There's one
 exception, though: you can only use one colon (to start the attribute list);
@@ -299,13 +327,27 @@ so the parser knows the name (and possibly prototype) while it processes the
 body. Thus C<fun foo($x) :($) { $x }> really turns into
 C<sub foo ($); sub foo ($) { my ($x) = @_; $x }>.
 
+If you want to wrap C<Function::Parameters>, you may find C<import_into>
+helpful. It lets you specify a target package for the syntax magic, as in:
+
+  package Some::Wrapper;
+  use Function::Parameters ();
+  sub import {
+    my $caller = caller;
+    Function::Parameters::import_into $caller;
+    # or Function::Parameters::import_into $caller, 'other_keyword';
+  }
+
+C<import_into> is not exported by this module, so you have to use a fully
+qualified name to call it.
+
 =head1 AUTHOR
 
 Lukas Mai, C<< <l.mai at web.de> >>
 
 =head1 COPYRIGHT & LICENSE
 
-Copyright 2009 Lukas Mai.
+Copyright 2010 Lukas Mai.
 
 This program is free software; you can redistribute it and/or modify it
 under the terms of either: the GNU General Public License as published