Hi, I have not been able to solve your coercion problem yet, but you might be interested in Types::Common::String (which comes bundled with Type::Tiny) for working with strings, string lengths, etc.

Hope this helps!

I am familair with and did use StrLength for this code but I was not sure if it inherited from NonEmptyStr which would cause the data to fail validation, StrLenght[1, 2871] might work but if the value meets the constraint, there is no way to coerce it.


Dermot

I believe it inherits from SimpleStr which allows zero length.

FWIW here's my code, which exercises the coercion when the string is empty, but does not seem to apply it. ( Update: added debug and showed output )

use strict;
use warnings;
use feature 'say', 'state';
use Types::Standard 'Undef';
use Types::Common::String 'SimpleStr','StrLength';
use Type::Params 'compile';

state $check = compile (
    Undef | (SimpleStr & (StrLength[1,4]))->plus_coercions(
        SimpleStr, sub { warn 'coercing'; length ? $_ : undef },
    )
);

#no warnings 'uninitialized';

for my $str ( undef, '', 'abcd', 'abcde' ) {
    my $label = ! defined($str) ? 'undef' : ! length ($str) ? 'empty' 
+: $str;
    my $checked = $check->($str);

    say sprintf('%s : >%s<', $label, $str);
}
[download]

This outputs:

Use of uninitialized value in sprintf at 11130005.pl line 20.
undef : ><
coercing at 11130005.pl line 10.
empty : ><
abcd : >abcd<
coercing at 11130005.pl line 10.
Value "abcde" did not pass type constraint "Undef|__ANON__" (in $_[0])
+ at 11130005.pl line 18
    "Undef|__ANON__" requires that the value pass "Undef" or "__ANON__
+"
    Value "abcde" did not pass type constraint "Undef"
        Value "abcde" did not pass type constraint "Undef"
        "Undef" is defined as: (!defined($_))
    Value "abcde" did not pass type constraint
        "__ANON__" is a subtype of "SimpleStr&StrLength[1,4]"
        "SimpleStr&StrLength[1,4]" requires that the value pass "Simpl
+eStr" and "StrLength[1,4]"
        Value "abcde" did not pass type constraint "StrLength[1,4]"
        "StrLength[1,4]" expects length($_) to be between 1 and 4
        length($_) is 5
[download]

Hope this helps!



The way forward always starts with a minimal test.

Something like this?

use Types::Standard qw( Str Maybe );
use Types::Common::String qw( StrLength );

my $Caption      = StrLength[ 1, 2780 ];
my $EmptyStr     = Str->where( q{ $_ eq '' } );
my $MaybeCaption = Maybe->of( $Caption )->plus_coercions( $EmptyStr =>
+ q{ undef } );


use Test::More;

ok( $MaybeCaption->check( 'My pic' ), 'Good caption passes type constr
+aint' );
ok( $MaybeCaption->check( undef ), 'Undef passes type constraint' );
ok( ! $MaybeCaption->check( [] ), 'Arrayref fails type constraint' );
is( $MaybeCaption->coerce( '' ), undef, 'Empty string coerced to undef
+' );
[download]

Basically, add the coercion to the Maybe[Caption], not to Caption.

But the important thing is to make sure that the empty string isn't considered a valid Caption. Because if a value is valid, it is never coerced.

I was hoping you'd reply Toby, thank you.

I made a couple of changes to the code so it compiles, and added a test to see that one can pass in the empty string and it will pass validation by being coerced to undef. But the syntax to do this must be wrong:

ok( $Caption->check( $Caption->coerce('') ), 'Empty string passes' );
[download]

... I feel sure that there's a way to avoid calling coerce manually.

Here's the revised test script:

use Types::Standard qw( Maybe Str );
use Types::Common::String qw( StrLength );

my $NonEmptyCaption = StrLength[ 1, 10 ];

my $EmptyStr = Str->where( q{ $_ eq '' } );

my $Caption = (Maybe[$NonEmptyCaption])->plus_coercions(
    $EmptyStr => 'undef',
);


use Test::More;

ok( $Caption->check('My pic'),               'Good caption passes' );
ok( ! $Caption->check('This is too long'),   'Bad caption fails' );
ok( $Caption->check(undef),                  'Undef passes' );
ok( ! $Caption->check([]),                   'Arrayref fails' );
is( $Caption->coerce(''), undef,             'Empty string coerced to 
+undef' );
ok( $Caption->check( $Caption->coerce('') ), 'Empty string passes' );


done_testing;
[download]

Outputs:

perl 11130005-3.pl

ok 1 - Good caption passes
ok 2 - Bad caption fails
ok 3 - Undef passes
ok 4 - Arrayref fails
ok 5 - Empty string coerced to undef
ok 6 - Empty string passes
1..6
[download]

Wonder if there is a more idiomatic way to do the check when a coercion is used. Thanks!



The way forward always starts with a minimal test.

... I feel sure that there's a way to avoid calling coerce manually.

That was why I used Types::Params because the POD says: ...it will check the arguments passed to it conform to the spec (coercing them if appropriate)

Otherwise I've had to relie on has_coercions before attempting to call coerce

If there is another way though, I would love to know about it.

Dermot

I too hoped you'd reply.


Your code is far less verbose than mine too.

There are a couple of concepts that are new to me there, I've not come across of before and I haven't see a Type modified with where in that way either. I only considered where in the constructor so that is really useful.

...

my $MaybeCaption = Maybe
    ->of( $LongCaption )
    ->plus_coercions( $EmptyStr => q{ undef } );
[download]

Really appreciate the help.
Dermot

of is a shorthand for parameterizing a type. If you do something like this, it will fail:

if ( ArrayRef[Int]->check( \@numbers ) ) {
  ...;
}
[download]

And you need to add some parentheses which look pretty ugly:

if ( ( ArrayRef[Int] )->check( \@numbers ) ) {
  ...;
}
[download]

The of method look a little nicer:

if ( ArrayRef->of( Int )->check( \@numbers ) ) {
  ...;
}
[download]

And where is a shorthand for creating a child type with an additional restriction.

Hire me at Toby Ink Ltd or Join my OnlyFans