use XSLoader;
BEGIN {
- our $VERSION = '0.06';
+ our $VERSION = '0.06_01';
XSLoader::load;
}
shift => '$class',
},
);
+for my $k (keys %type_map) {
+ $type_map{$k . '_strict'} = {
+ %{$type_map{$k}},
+ check_argument_count => 1,
+ };
+}
sub import {
my $class = shift;
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
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>).
...
}
-except that none of the parameters are in scope in the expressions that specify
-default values. Thus:
+You can even refer to previous parameters in the same parameter list:
- my $var = "outer";
+ print fun ($x, $y = $x + 1) { "$x and $y" }->(9); # "9 and 10"
- fun foo($var, $wat = $var) {
- # $wat will default to "outer", not to what was passed
- # as the first argument!
- ...
- }
+This also works with the implicit first parameter of methods:
-This may change in a future version of this module.
+ method scale($factor = $self->default_factor) {
+ $self->{amount} *= $factor;
+ }
=item C<check_argument_count>
(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:
{
shift => '$self',
}
+C<'method_strict'> is like C<'method'> but with
+C<< check_argument_count => 1 >>.
+
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
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
# 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) = @_;
...
};
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 ();