---
name: "Types::Standard::Dict"
section: "3pm"
platform: "linux"
package: "perl-type-tiny"
version: "2.010001-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Types::Standard::Dict"
---

# Types::Standard::Dict(3pm)

exporter utility and utility functions for the Dict type constraint

## NAME

Types::Standard::Dict - exporter utility and utility functions for the Dict type constraint

## STATUS

This module is not covered by the Type-Tiny stability policy.

## DESCRIPTION

This is mostly internal code, but has one public-facing function.

### 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 { ... } };
```

## BUGS

Please report any bugs to \<https://github.com/tobyink/p5-type-tiny/issues\>.

## SEE ALSO

Types::Standard.

## AUTHOR

Toby Inkster \<tobyink@cpan.org\>.

## COPYRIGHT AND LICENCE

This software is copyright (c) 2013-2025 by Toby Inkster.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

## DISCLAIMER OF WARRANTIES

THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.