=encoding utf8

=for comment POD_DERIVED_INDEX_GENERATED
The following documentation is automatically generated.  Please do not edit
this file, but rather the original, inline with Acme::Signature::Arity
at lib/Acme/Signature/Arity.pm
(on the system that originally ran this).
If you do edit this file, and don't want your changes to be removed, make
sure you change the first line.

=cut

=head1 NAME

Acme::Signature::Arity - provides reliable, production-ready signature introspection

=head1 DESCRIPTION

You'll know if you need this.

If you're just curious, perhaps start with L<https://www.nntp.perl.org/group/perl.perl5.porters/2021/11/msg262009.html>.

No part of this is expected to work in any way when given a sub that has a prototype.
There are other tools for those: L<Sub::Util>.

For subs that don't have a prototype, this is I<also> not expected to work. It might help
demonstrate where to look if you wanted to write something proper, though.

=head1 Exported functions

=head2 arity

Returns the C<UNOP_aux> details for the first opcode for a coderef CV.
If that code uses signatures, this might give you some internal details
which mean something about the expected parameters.

Expected return information, as a list:

=over 4

=item * number of required scalar parameters

=item * number of optional scalar parameters (probably because there are defaults)

=item * a character representing the slurping behaviour, might be '@' or '%', or nothing (undef?) if it's
just a fixed list of scalar parameters

=back

This can also throw exceptions. That should only happen if you give it something that isn't
a coderef, or if internals change enough that the entirely-unjustified assumptions made by
this module are somehow no longer valid. Maybe they never were in the first place.

=head2 max_arity

Takes a coderef, returns a number or C<undef>.

If the code uses signatures, this tells you how many parameters you could
pass when calling before it complains - C<undef> means unlimited.

Should also work when there are no signatures, just gives C<undef> again.

=head2 min_arity

Takes a coderef, returns a number or C<undef>.

If the code uses signatures, this tells you how many parameters you need to
pass when calling - 0 means that no parameters are required.

Should also work when there are no signatures, returning 0 in that case.

=head2 coderef_ignoring_extra

Given a coderef, returns a coderef (either the original or wrapped)
which won't complain if you try to pass more parameters than it was expecting.

This is intended for library authors in situations like this:

 $useful_library->each(sub ($item) { say "item here: $item" });

where you later want to add optional new parameters, and don't trust your users
to include the mandatory C<, @> signature definition that indicates excess
parameters can be dropped.

Usage - let's say your first library version looked like this:

 sub each ($self, $callback) {
  my $code = $callback;
  for my $item ($self->{items}->@*) {
   $code->($item);
  }
 }

and you later want to pass the index as an extra parameter, without breaking existing code
that assumed there would only ever be one callback parameter...

 sub each ($self, $callback) {
  my $code = coderef_ignoring_extra($callback);
  for my $idx (0..$#{$self->{items}}) {
   $code->($self->{items}{$idx}, $idx);
  }
 }

Your library is now at least somewhat backwards-compatible, without sacrificing too
many signature-related arity checking features: code expecting the new version
will still complain if required parameters are not provided.

=head1 AUTHOR

C<TEAM@cpan.org>

=head1 WARRANTY

None, it's an Acme module, you shouldn't even be reading this.

=head1 INHERITED METHODS

=over 4

=item L<Exporter>

L<as_heavy|Exporter/as_heavy>, L<export|Exporter/export>, L<export_fail|Exporter/export_fail>, L<export_ok_tags|Exporter/export_ok_tags>, L<export_tags|Exporter/export_tags>, L<export_to_level|Exporter/export_to_level>, L<import|Exporter/import>, L<require_version|Exporter/require_version>

=back

