add *_strict variants of all symbolic types

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

diff --git a/lib/Function/Parameters.pm b/lib/Function/Parameters.pm
index b0d2b2b..1eeae05 100644 (file)
--- a/lib/Function/Parameters.pm
+++ b/lib/Function/Parameters.pm
@@ -48,6 +48,12 @@ my %type_map = (
                shift => '$class',
        },
 );
+for my $k (keys %type_map) {
+       $type_map{$k . '_strict'} = {
+               %{$type_map{$k}},
+               check_argument_count => 1,
+       };
+}
 
 sub import {
        my $class = shift;
@@ -214,7 +220,7 @@ list consists of comma-separated variables.
 
 The effect of C<fun foo($bar, $baz) {> is as if you'd written
 C<sub foo { my ($bar, $baz) = @_; >, i.e. the parameter list is simply
-copied into L<my|perlfunc/my> and initialized from L<@_|perlvar/"@_">.
+copied into L<my|perlfunc/my-EXPR> and initialized from L<@_|perlvar/"@_">.
 
 In addition you can use C<method>, which understands the same syntax as C<fun>
 but automatically creates a C<$self> variable for you. So by writing
@@ -242,8 +248,9 @@ Or more concretely:
 The first line creates two keywords, C<proc> and C<meth> (for defining
 functions and methods, respectively). The last two lines only create one
 keyword. Generally the hash keys (keywords) can be any identifiers you want
-while the values (types) have to be either C<'function'>, C<'method'>,
-C<'classmethod'>, or a hash reference (see below). The main difference between
+while the values (types) have to be either a hash reference (see below) or
+C<'function'>, C<'method'>, C<'classmethod'>, C<'function_strict'>,
+C<'method_strict'>, or C<'classmethod_strict'>. The main difference between
 C<'function'> and C<'method'> is that C<'method'>s automatically
 L<shift|perlfunc/shift> their first argument into C<$self> (C<'classmethod'>s
 are similar but shift into C<$class>).
@@ -382,6 +389,9 @@ Plain C<'function'> is equivalent to:
 
 (These are all default values so C<'function'> is also equivalent to C<{}>.)
 
+C<'function_strict'> is like C<'function'> but with
+C<< check_argument_count => 1 >>.
+
 C<'method'> is equivalent to:
 
  {
@@ -392,6 +402,9 @@ C<'method'> is equivalent to:
    shift => '$self',
  }
 
+C<'method_strict'> is like C<'method'> but with
+C<< check_argument_count => 1 >>.
+
 C<'classmethod'> is equivalent to:
 
  {
@@ -402,6 +415,9 @@ C<'classmethod'> is equivalent to:
    shift => '$class',
  }
 
+C<'classmethod_strict'> is like C<'classmethod'> but with
+C<< check_argument_count => 1 >>.
+
 =head2 Syntax and generated code
 
 Normally, Perl subroutines are not in scope in their own body, meaning the
@@ -415,7 +431,7 @@ 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 need L<subroutine attributes|perlsub/"Subroutine Attributes">, you can
+If you need L<subroutine attributes|perlsub/Subroutine-Attributes>, you can
 put them after the parameter list with their usual syntax.
 
 Syntactically, these new parameter lists live in the spot normally occupied
@@ -458,6 +474,7 @@ And the generated code:
    # vvv   only if check_argument_count is enabled    vvv
    Carp::croak "Not enough arguments for fun (anon)" if @_ < 2;
    Carp::croak "Too many arguments for fun (anon)" if @_ > 2;
+   # ^^^                                              ^^^
    my ($p, $q) = @_;
    ...
  };
@@ -466,7 +483,8 @@ And the generated code:
 
 If you want to wrap L<Function::Parameters>, you just have to call its
 C<import> method. It always applies to the file that is currently being parsed
-and its effects are lexical (i.e. it works like L<warnings> or L<strict>):
+and its effects are L<lexical|perlpragma> (i.e. it works like L<warnings> or
+L<strict>).
 
  package Some::Wrapper;
  use Function::Parameters ();