package Function::Parameters;
use v5.14.0;
-
use warnings;
use Carp qw(confess);
use XSLoader;
BEGIN {
- our $VERSION = '1.00_02';
- our $XS_VERSION = $VERSION;
- $VERSION = eval $VERSION;
+ our $VERSION = '1.0104';
XSLoader::load;
}
sub _assert_valid_attributes {
my ($attrs) = @_;
- $attrs =~ /^\s*:\s*[^\W\d]\w*\s*(?:(?:\s|:\s*)[^\W\d]\w*\s*)*(?:\(|\z)/
- or confess qq{"$attrs" doesn't look like valid attributes};
+ $attrs =~ m{
+ ^ \s*+
+ : \s*+
+ (?&ident) (?! [^\s:(] ) (?¶m)?+ \s*+
+ (?:
+ (?: : \s*+ )?
+ (?&ident) (?! [^\s:(] ) (?¶m)?+ \s*+
+ )*+
+ \z
+
+ (?(DEFINE)
+ (?<ident>
+ [^\W\d]
+ \w*+
+ )
+ (?<param>
+ \(
+ [^()\\]*+
+ (?:
+ (?:
+ \\ .
+ |
+ (?¶m)
+ )
+ [^()\\]*+
+ )*+
+ \)
+ )
+ )
+ }sx or confess qq{"$attrs" doesn't look like valid attributes};
}
my @bare_arms = qw(function method);
my %type_map = (
- function => {
- name => 'optional',
- default_arguments => 1,
+ function => {
+ name => 'optional',
+ default_arguments => 1,
check_argument_count => 0,
- named_parameters => 1,
- types => 1,
+ named_parameters => 1,
+ types => 1,
},
- method => {
- name => 'optional',
- default_arguments => 1,
+ method => {
+ name => 'optional',
+ default_arguments => 1,
check_argument_count => 0,
- named_parameters => 1,
- types => 1,
- attrs => ':method',
- shift => '$self',
- invocant => 1,
+ named_parameters => 1,
+ types => 1,
+ attrs => ':method',
+ shift => '$self',
+ invocant => 1,
},
- classmethod => {
- name => 'optional',
- default_arguments => 1,
+ classmethod => {
+ name => 'optional',
+ default_arguments => 1,
check_argument_count => 0,
- named_parameters => 1,
- types => 1,
- attributes => ':method',
- shift => '$class',
- invocant => 1,
+ named_parameters => 1,
+ types => 1,
+ attributes => ':method',
+ shift => '$class',
+ invocant => 1,
},
);
for my $k (keys %type_map) {
my $type = $spec{$kw};
my $flags =
- $type->{name} eq 'prohibited' ? FLAG_ANON_OK :
- $type->{name} eq 'required' ? FLAG_NAME_OK :
- FLAG_ANON_OK | FLAG_NAME_OK
+ $type->{name} eq 'prohibited' ? FLAG_ANON_OK :
+ $type->{name} eq 'required' ? FLAG_NAME_OK :
+ FLAG_ANON_OK | FLAG_NAME_OK
;
- $flags |= FLAG_DEFAULT_ARGS if $type->{default_arguments};
+ $flags |= FLAG_DEFAULT_ARGS if $type->{default_arguments};
$flags |= FLAG_CHECK_NARGS | FLAG_CHECK_TARGS if $type->{check_argument_count};
- $flags |= FLAG_INVOCANT if $type->{invocant};
- $flags |= FLAG_NAMED_PARAMS if $type->{named_parameters};
- $flags |= FLAG_TYPES_OK if $type->{types};
+ $flags |= FLAG_INVOCANT if $type->{invocant};
+ $flags |= FLAG_NAMED_PARAMS if $type->{named_parameters};
+ $flags |= FLAG_TYPES_OK if $type->{types};
$^H{HINTK_FLAGS_ . $kw} = $flags;
$^H{HINTK_SHIFT_ . $kw} = $type->{shift};
$^H{HINTK_ATTRS_ . $kw} = $type->{attrs};
The predefined type C<function> is equivalent to:
{
- name => 'optional',
- invocant => 0,
- default_arguments => 1,
+ name => 'optional',
+ invocant => 0,
+ default_arguments => 1,
check_argument_count => 0,
}
C<method> is equivalent to:
{
- name => 'optional',
- shift => '$self',
- invocant => 1,
- attributes => ':method',
- default_arguments => 1,
+ name => 'optional',
+ shift => '$self',
+ invocant => 1,
+ attributes => ':method',
+ default_arguments => 1,
check_argument_count => 0,
}
C<classmethod> is equivalent to:
{
- name => 'optional',
- shift => '$class',
- invocant => 1,
- attributes => ':method',
- default_arguments => 1,
+ name => 'optional',
+ shift => '$class',
+ invocant => 1,
+ attributes => ':method',
+ default_arguments => 1,
check_argument_count => 0,
}
function, and returns either C<undef> (if it knows nothing about the function)
or a L<Function::Parameters::Info> object describing the parameter list.
+Note: This feature is implemented using L<Moo>, so you'll need to have L<Moo>
+installed if you want to call C<Function::Parameters::info> (alternatively, if
+L<Moose> is already loaded by the time C<Function::Parameters::info> is first
+called, it will use that instead).
+
See L<Function::Parameters::Info> for examples.
=head2 Wrapping C<Function::Parameters>
If you are in "lax" mode, nothing further happens and the types are ignored. If
you are in "strict" mode, C<Function::Parameters> generates code to make sure
any values passed in conform to the type (via
-L<< C<< $constraint->check($value) >>|Moose::Meta::TypeConstraint/$constraint->check($value) >>.
+L<< C<< $constraint->check($value) >>|Moose::Meta::TypeConstraint/$constraint->check($value) >>).
In addition, these type constraints are inspectable through the
L<Function::Parameters::Info> object returned by
=head1 COPYRIGHT & LICENSE
-Copyright 2010, 2011, 2012 Lukas Mai.
+Copyright 2010-2013 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