使用MooseX :: Params :: Validate传递条件参数

Question

I work alot with Moose packages in Perl that use MooseX::Params::Validate to define an interface. These interfaces tend to be rather flexible and allow for multiple optional parameters. Unfortunately this is Perl so the return types will vary based on the optional parameters and there is a benefit to passing the optional parameters in most cases when defined in the caller. Various methods exported from MooseX::Params::Validate are used in this codebase so due to the various ways that package will be handled undef parameters I can not passing it will be graceful in anyway. I tend to use the following method, but it comes up a lot in reviews, and I would like to ask if there is another way to achieve this flexibility.

use strict;
use warnings;

my $bar;

Foo->foo({
    foo => 'I, Foo need a VERY flexible interface. ',
    $bar ? ( bar => $bar ) : ()
});

$bar = "Very flexible...";

Foo->foo({
    foo => 'I, Foo need a VERY flexible interface. ',
    $bar ? ( bar => $bar ) : ()
});

package Foo;

use Moose;
use MooseX::Params::Validate;

sub foo {
    my $self = shift;
    my ( $foo, $bar ) = validated_list(
      \@_,
      foo => { isa => 'Str' },
      bar => { isa => 'Str', optional => 1 },
    );

    print $foo . $bar . "\n";
}

1;

The ternary operator to check the variables defined state is what always leaves me wanting a // type parameter option, but I can't see anywhere this type of operation is supported.

Answers for the caller is preferred as I don't want to (won't) change the interface of the various packages, but I am open to answers showing methods of handling undef parameters values being passed as well.

Answer 1

As Craig Estey said in his comment, I think it would make sense just to pass in the options to your function and not having to care whether they are undefined or not. Instead, strip undefined hash keys as a preprocessing step before calling MooseX::Params::Validate::validated_list() . For example:

use strict;
use warnings;

my $bar;

Foo->foo({
    foo => 'I, Foo need a VERY flexible interface. ',
    bar => $bar
});

package Foo;

use Moose;
use MooseX::Params::Validate ();

sub foo {
    my $self = shift;

    my ( $foo, $bar ) = validated_list(
      \@_,
      foo => { isa => 'Str' },
      bar => { isa => 'Str', optional => 1 },
    );

    $bar //= 'undef';  # Just to avoid printing warning: Use of uninitialized value 
    print $foo . $bar . "\n";
}

sub validated_list {
    for (keys %{ $_[0]->[0] } ) {
        delete $_[0]->[0]{$_} if !defined $_[0]->[0]{$_};
    }
    return MooseX::Params::Validate::validated_list( @_ );
}
1;

Answer 2

The Maybe type might be what you are looking for. Normally MooseX::Params::Validate does not allow undef to be passed for things liked Str, forcing you to use a ternary to conditionally pass or not pass it. An optional variable will be undef anyways in the subroutine, but with Maybe it makes it easier for the caller to just pass through the variables they have (which may or not be defined).

sub foo {
    my $self = shift;
    my ( $foo, $bar ) = validated_list(
      \@_,
      foo => { isa => 'Str' },
      bar => { isa => 'Maybe[Str]', optional => 1 }
    );

    print $foo . $bar . "\n";
}

By using Maybe[Str], it will now accept the undef value and you can handle this undef how you see fit in your subroutine.

Maybe[`a] accepts either `a or undef.

http://search.cpan.org/dist/Moose-2.0604/lib/Moose/Manual/Types.pod