In general, I like signatures. They're great. But there's one situation in which I think the arity checking gets it wrong. Passing too many values for the signature should not be fatal. In event-based code it's often the case that users pass in callbacks as CODE references, expecting your event system to invoke them. If users always pass me a callback and I always used to do $cb->($thing) and now I want to pass more data, before signatured subs it was always safe to just do $cb->($thing, @more) because in practice everyone just handled their args by doing: callback => sub { my ($thing) = @_; ... } and nobody would mind the extra values. But suddenly now if they used signatures for this by passing callback => sub ($thing) { ... } then it'll complain at runtime if I pass any more values. Which sucks. So right now we're basically forcing everyone to pass callbacks around with a trailing slurpy, as `(..., @)`, at the end of their signature, "just in case" If we had some sort of introspection we could do some kind of `bounded_invoke( $callback, @args )` which would slice @args to no more than the signature says it wants. Though overall, I think signature checking has slightly the wrong behaviour here. It should be asymmetric: die if too few values, but only warn if too many. It should warn from the caller's perspective on a name that can be easily no warnings'd away { no warnings 'too_many_args'; $callback->($thing, @more); # silently discard if too many } It's still experimental - it's not too late to change this ;) -- Paul "LeoNerd" Evans leonerd@leonerd.org.uk | https://metacpan.org/author/PEVANS http://www.leonerd.org.uk/ | https://www.tindie.com/stores/leonerd/Thread Next