Function

Types::Standard::Dict::combine(@dicts)

Creates a combined type constraint, attempting to be permissive.

The following two types should be equivalent:

  my $type1 = Types::Standard::Dict::combine(
    Dict[ name => Str ],
    Dict[ age => Int, Slurpy[HashRef[Int]] ],
    Dict[ id => Str, name => ArrayRef, Slurpy[ArrayRef] ],
  );
  
  my $type2 = Dict[
    name => Str|ArrayRef,
    age => Int,
    id => Str,
    Slurpy[ HashRef[Int] | ArrayRef ],
  ];
    

Note that a hashref satisfying the combined type wouldn't satisfy any of the individual Dict constraints, nor vice versa!

This function can be exported:

  use Types::Standard -types;
  use Types::Standard::Dict combine => { -as => 'combine_dicts' };
  
  my $type1 = combine_dicts(
    Dict[ name => Str ],
    Dict[ age => Int, Slurpy[HashRef[Int]] ],
    Dict[ id => Str, name => ArrayRef, Slurpy[ArrayRef] ],
  );
    

Exports

Types::Standard::Dict can be used experimentally as an exporter.

  use Types::Standard 'Str';
  use Types::Standard::Dict Credentials => { of => [
    username => Str,
    password => Str,
  ] };

This will export the following functions into your namespace:

"Credentials"

is_Credentials( $value )

assert_Credentials( $value )

to_Credentials( $value )

Multiple types can be exported at once:

  use Types::Standard -types;
  
  use Types::Standard::Dict (
    Credentials => { of => [
      username => Str,
      password => Str,
    ] },
    Headers => { of => [
      'Content-Type' => Optional[Str],
      'Accept'       => Optional[Str],
      'User-Agent'   => Optional[Str],
    ] },
  );
  
  # Exporting this separately so it can use the types defined by
  # the first export.
  use Types::Standard::Dict (
    HttpRequestData => { of => [
      credentials => Credentials,
      headers     => Headers,
      url         => Str,
      method      => Enum[ qw( OPTIONS HEAD GET POST PUT DELETE PATCH ) ],
    ] },
  );
  
  assert_HttpRequestData( {
    credentials => { username => 'bob', password => 's3cr3t' },
    headers     => { 'Accept' => 'application/json' },
    url         => 'http://example.net/api/v1/stuff',
    method      => 'GET',
  } );

It's possible to further constrain the hashref using "where":

  use Types::Standard::Dict MyThing => { of => [ ... ], where => sub { ... } };