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;
}
# function with prototype
- fun mymap($fun, @args) :(&@) {
+ fun mymap($fun, @args)
+ :(&@)
+ {
my @res;
for (@args) {
push @res, $fun->($_);
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
(subroutine name, parameter list, default arguments, prototype, default
attributes, attributes, argument count checks, and implicit C<$self>):
- method foo($x, $y, $z = sqrt 5) :($$$;$) :lvalue :Banana(2 + 2) {
+ method foo($x, $y, $z = sqrt 5)
+ :($$$;$)
+ :lvalue
+ :Banana(2 + 2)
+ {
...
}
Another example:
- my $coderef = fun ($p, $q) :(;$$)
+ my $coderef = fun ($p, $q)
+ :(;$$)
:lvalue
:Gazebo((>:O)) {
...
# 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 ();