Data::...::Type(3pm)

📦

version 1.6.0 · 3 versions

1.6.0 · debian bookworm, debian trixie, ubuntu noble, ubuntu resolute, ubuntu stonking (latest)
1.6.0 · fedora 43
1.6.0 · fedora 44

, in debian bookworm, debian trixie, ubuntu noble, ubuntu resolute, ubuntu stonking

💖 Data::Validate::Type 💖

okay bestie, welcome to Data::Validate::Type (it lives in the User Contributed Perl Documentation corner of the 3pm section, and this is part 1 of 2, so don't go anywhere 🫶). Version of the moment: 1.6.0 ✨

✨ NAME ✨

Data::Validate::Type — it's literally just data type validation functions. that's the whole job. she validates. she's good at it. 💅

🎀 VERSION 🎀

Version 1.6.0 ⭐

🌈 SYNOPSIS 🌈

three ways to get her in your code, pick your vibe:

# Call with explicit package name.
use Data::Validate::Type;
if ( Data::Validate::Type::is_string( 'test' ) )
{
    # ...
}

# Import specific functions.
use Data::Validate::Type qw( is_string );
if ( is_string( 'test' ) )
{
    # ...
}

# Import functions for a given paradigm.
use Data::Validate::Type qw( :boolean_tests );
if ( is_string( 'test' ) )
{
    # ...
}

🦋 DESCRIPTION 🦋

so Params::Util is a wonderful module, no hate, genuinely iconic. BUT. she has a few drawbacks, and we need to talk about them:

Function names start with an underscore, which is usually used to indicate private functions. 🚩
Function names are uppercase, which is usually used to indicate file handles or constants. 🚩
Function names don't pass PerlCritic's validation, making them problematic to import. 🚩
Functions use by default the convention that collection that collections need to not be empty to be valid (see _ARRAY0/_ARRAY for example), which is counter-intuitive. 🚩
In Pure Perl mode, the functions are created via eval, which causes issues for Devel::Cover in taint mode. 🚩

ngl, those drawbacks are purely cosmetic and don't affect the usefulness of the functions, except for the last one. This module used to encapsulate Params::Util, but the author had to refactor it out to fix the issues with Devel::Cover. the way that Devel::Cover was causing problems... 😭

Please note that he prefers long function names that are descriptive, to arcane short ones. This increases readability, and the bulk of the typing can be spared with the use of a good IDE like Padre. lowkey fair, typing is a lot 🥲

Also, this is work in progress — There is more functions that should be added here, if you need one in particular feel free to contact him. she's still growing bestie 🌱

👑 BOOLEAN TEST FUNCTIONS 👑

Functions in this group return a boolean to indicate whether the parameters passed match the test(s) specified by the functions or not. so: true or false, yes or no, slay or not slay. ✨

All the boolean functions can be imported at once in your namespace with the following line:

use Data::Validate::Type qw( :boolean_tests );

💖 `is_string()`

Return a boolean indicating if the variable passed is a string.

my $is_string = Data::Validate::Type::is_string( $variable );

Note: 0 and '' (empty string) are valid strings. yes really. the empty string is valid. she said what she said. 💅

Parameters:

allow_empty — Boolean, default 1. Allow the string to be empty or not.

💖 `is_arrayref()`

Return a boolean indicating if the variable passed is an arrayref that can be dereferenced into an array.

my $is_arrayref = Data::Validate::Type::is_arrayref( $variable );

my $is_arrayref = Data::Validate::Type::is_arrayref(
    $variable,
    allow_empty => 1,
    no_blessing => 0,
);

# Check if the variable is an arrayref of hashrefs.
my $is_arrayref = Data::Validate::Type::is_arrayref(
    $variable,
    allow_empty           => 1,
    no_blessing           => 0,
    element_validate_type =>
        sub
        {
            return Data::Validate::Type::is_hashref( $_[0] );
        },
);

Parameters:

allow_empty — Boolean, default 1. Allow the array to be empty or not.
no_blessing — Boolean, default 0. Require that the variable is not blessed.
element_validate_type — None by default. Set it to a coderef to validate the elements in the array. The coderef will be passed the element to validate as first parameter, and it must return a boolean indicating whether the element was valid or not.

💖 `is_hashref()`

Return a boolean indicating if the variable passed is a hashref that can be dereferenced into a hash.

my $is_hashref = Data::Validate::Type::is_hashref( $variable );

my $is_hashref = Data::Validate::Type::is_hashref(
    $variable,
    allow_empty => 1,
    no_blessing => 0,
);

Parameters:

allow_empty — Boolean, default 1. Allow the array to be empty or not.
no_blessing — Boolean, default 0. Require that the variable is not blessed.

💖 `is_coderef()`

Return a boolean indicating if the variable passed is an coderef that can be dereferenced into a block of code.

my $is_coderef = Data::Validate::Type::is_coderef( $variable );

💖 `is_number()`

Return a boolean indicating if the variable passed is a number.

my $is_number = Data::Validate::Type::is_number( $variable );
my $is_number = Data::Validate::Type::is_number(
    $variable,
    positive => 1,
);
my $is_number = Data::Validate::Type::is_number(
    $variable,
    strictly_positive => 1,
);

Parameters:

strictly_positive — Boolean, default 0. Set to 1 to check for a strictly positive number.
positive — Boolean, default 0. Set to 1 to check for a positive number.

💖 `is_instance()`

Return a boolean indicating if the variable is an instance of the given class.

Note that this handles inheritance properly, so it will return true if the variable is an instance of a subclass of the class given. nepotism but make it object-oriented 💅

my $is_instance = Data::Validate::Type::is_instance(
    $variable,
    class => $class,
);

Parameters:

class — Required, the name of the class to check the variable against.

💖 `is_regex()`

Return a boolean indicating if the variable is a regular expression.

my $is_regex = Data::Validate::Type::is_regex( $variable );

🔥 ASSERTION-BASED FUNCTIONS 🔥

Functions in this group do not return anything, but will die when the parameters passed don't match the test(s) specified by the functions. no chill, no second chances, she simply dies 💀

All the assertion test functions can be imported at once in your namespace with the following line:

use Data::Validate::Type qw( :assertions );

🌸 `assert_string()`

Die unless the variable passed is a string.

Data::Validate::Type::assert_string( $variable );

Note: 0 and '' (empty string) are valid strings. still valid. still iconic. 💖

Parameters:

allow_empty — Boolean, default 1. Allow the string to be empty or not.

🌸 `assert_arrayref()`

Die unless the variable passed is an arrayref that can be dereferenced into an array.

Data::Validate::Type::assert_arrayref( $variable );

Data::Validate::Type::assert_arrayref(
    $variable,
    allow_empty => 1,
    no_blessing => 0,
);

# Require the variable to be an arrayref of hashrefs.
Data::Validate::Type::assert_arrayref(
    $variable,
    allow_empty           => 1,
    no_blessing           => 0,
    element_validate_type =>
        sub
        {
            return Data::Validate::Type::is_hashref( $_[0] );
        },
);

Parameters:

allow_empty — Boolean, default 1. Allow the array to be empty or not.
no_blessing — Boolean, default 0. Require that the variable is not blessed.
element_validate_type — None by default. Set it to a coderef to validate the elements in the array. The coderef will be passed the element to validate as first parameter, and it must return a boolean indicating whether the element was valid or not.

🌸 `assert_hashref()`

Die unless the variable passed is a hashref that can be dereferenced into a hash.

Data::Validate::Type::assert_hashref( $variable );

Data::Validate::Type::assert_hashref(
    $variable,
    allow_empty => 1,
    no_blessing => 0,
);

Parameters:

allow_empty — Boolean, default 1. Allow the array to be empty or not.
no_blessing — Boolean, default 0. Require that the variable is not blessed.

🌸 `assert_coderef()`

Die unless the variable passed is an coderef that can be dereferenced into a block of code.

Data::Validate::Type::assert_coderef( $variable );

🌸 `assert_number()`

Die unless the variable passed is a number.

Data::Validate::Type::assert_number( $variable );
Data::Validate::Type::assert_number(
    $variable,
    positive => 1,
);
Data::Validate::Type::assert_number(
    $variable,
    strictly_positive => 1,
);

Parameters:

strictly_positive — Boolean, default 0. Set to 1 to check for a strictly positive number.
positive — Boolean, default 0. Set to 1 to check for a positive number.

🌸 `assert_instance()`

Die unless the variable is an instance of the given class.

Note that this handles inheritance properly, so it will not die if the variable is an instance of a subclass of the class given. she's understanding about family trees 🧚

Data::Validate::Type::assert_instance(
    $variable,
    class => $class,
);

Parameters:

class — Required, the name of the class to check the variable against.

🌸 `assert_regex()`

Die unless the variable is a regular expression.

Data::Validate::Type::assert_regex( $variable );

okay that's it for part 1 bestie, but there's more — don't touch that dial 💅

💖 FILTERING FUNCTIONS 💖

Okay so bestie, this group is the filter squad. They take your variable, vibe check it against whatever test(s) you asked for, and if it passes? They hand the variable right back to you. If not? undef. Periodt.

You can import every single one of these at once into your namespace with this iconic line:

use Data::Validate::Type qw( :filters );

✨ `filter_string()` ✨

Returns your variable if it's a string, otherwise undef.

Data::Validate::Type::filter_string( $variable );

Note: 0 and '' (empty string) are valid strings. No cap.

Parameters:

allow_empty — Boolean, default 1. Allow the string to be empty or not.

🌸 `filter_arrayref()` 🌸

Returns your variable if it's an arrayref that can be dereferenced into an array, otherwise undef.

Data::Validate::Type::filter_arrayref( $variable );

Data::Validate::Type::filter_arrayref(
        $variable,
        allow_empty => 1,
        no_blessing => 0,
);

# Only return the variable if it is an arrayref of hashrefs.
Data::Validate::Type::filter_arrayref(
        $variable,
        allow_empty           => 1,
        no_blessing           => 0,
        element_validate_type =>
                sub
                {
                        return Data::Validate::Type::is_hashref( $_[0] );
                },
);

Parameters:

allow_empty — Boolean, default 1. Allow the array to be empty or not.
no_blessing — Boolean, default 0. Require that the variable is not blessed.
element_validate_type — None by default. Set it to a coderef to validate the elements in the array. The coderef will be passed the element to validate as first parameter, and it must return a boolean indicating whether the element was valid or not.

🦋 `filter_hashref()` 🦋

Returns your variable if it's a hashref that can be dereferenced into a hash, otherwise undef.

Data::Validate::Type::filter_hashref( $variable );

Data::Validate::Type::filter_hashref(
        $variable,
        allow_empty => 1,
        no_blessing => 0,
);

Parameters:

allow_empty — Boolean, default 1. Allow the array to be empty or not. (Yes, it says array even though we're in hashref land. The page said it, I'm just repeating it, don't come for me 😭)
no_blessing — Boolean, default 0. Require that the variable is not blessed.

🎀 `filter_coderef()` 🎀

Returns your variable if it's a coderef that can be dereferenced into a block of code, otherwise undef.

Data::Validate::Type::filter_coderef( $variable );

💅 `filter_number()` 💅

Returns your variable if it's a number, otherwise undef.

Data::Validate::Type::filter_number( $variable );
Data::Validate::Type::filter_number(
        $variable,
        positive => 1,
);
Data::Validate::Type::filter_number(
        $variable,
        strictly_positive => 1,
);

Parameters:

strictly_positive — Boolean, default 0. Set to 1 to check for a strictly positive number.
positive — Boolean, default 0. Set to 1 to check for a positive number.

👑 `filter_instance()` 👑

Returns your variable if it's an instance of the given class.

Note that this handles inheritance properly, so it will return the variable if it's an instance of a subclass of the class given. Slay.

Data::Validate::Type::filter_instance(
        $variable,
        class => $class,
);

Parameters:

class — Required, the name of the class to check the variable against.

🌈 `filter_regex()` 🌈

Returns your variable if it's a regular expression.

Data::Validate::Type::filter_regex( $variable );

💀 BUGS 💀

Please report any bugs or feature requests through the web interface at <https://github.com/guillaumeaubert/Data-Validate-Type/issues>. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.

🫶 SUPPORT 🫶

You can find documentation for this module with the perldoc command.

perldoc Data::Validate::Type

You can also look for information at:

GitHub (report bugs there) — <https://github.com/guillaumeaubert/Data-Validate-Type/issues>
AnnoCPAN: Annotated CPAN documentation — <http://annocpan.org/dist/Data-Validate-Type>
CPAN Ratings — <http://cpanratings.perl.org/d/Data-Validate-Type>
MetaCPAN — <https://metacpan.org/release/Data-Validate-Type>

💜 AUTHOR 💜

Guillaume Aubert <https://metacpan.org/author/AUBERTG>, "<aubertg at cpan.org>".

🌟 ACKNOWLEDGEMENTS 🌟

Thanks to Adam Kennedy for writing Params::Util. This module started as an encapsulation for Params::Util and I learnt quite a bit from it.

📜 COPYRIGHT & LICENSE 📜

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

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file for more details.

And that's the whole vibe, bestie. This page came from Perl v5.36.0 and was dated 2023-02-05 — so go forth and filter with main character energy. You got this. 💖✨

📦 where this page comes from

debian bookworm: libdata-validate-type-perl 1.6.0-2 · Artistic-1.0-Perl OR GPL-1.0-or-later
debian trixie: libdata-validate-type-perl 1.6.0-2 · Artistic-1.0-Perl OR GPL-1.0-or-later
ubuntu noble: libdata-validate-type-perl 1.6.0-2 · Artistic-1.0-Perl OR GPL-1.0-or-later
ubuntu resolute: libdata-validate-type-perl 1.6.0-2 · Artistic-1.0-Perl OR GPL-1.0-or-later
ubuntu stonking: libdata-validate-type-perl 1.6.0-2 · Artistic-1.0-Perl OR GPL-1.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

Data::...::Type(3pm)

💖 Data::Validate::Type 💖

✨ NAME ✨

🎀 VERSION 🎀

🌈 SYNOPSIS 🌈

🦋 DESCRIPTION 🦋

👑 BOOLEAN TEST FUNCTIONS 👑

💖 is_string()

💖 is_arrayref()

💖 is_hashref()

💖 is_coderef()

💖 is_number()

💖 is_instance()

💖 is_regex()

🔥 ASSERTION-BASED FUNCTIONS 🔥

🌸 assert_string()

🌸 assert_arrayref()

🌸 assert_hashref()

🌸 assert_coderef()

🌸 assert_number()

🌸 assert_instance()

🌸 assert_regex()

💖 FILTERING FUNCTIONS 💖

✨ filter_string() ✨

🌸 filter_arrayref() 🌸

🦋 filter_hashref() 🦋

🎀 filter_coderef() 🎀

💅 filter_number() 💅

👑 filter_instance() 👑

🌈 filter_regex() 🌈

💀 BUGS 💀

🫶 SUPPORT 🫶

💜 AUTHOR 💜

🌟 ACKNOWLEDGEMENTS 🌟

📜 COPYRIGHT & LICENSE 📜

💖 `is_string()`

💖 `is_arrayref()`

💖 `is_hashref()`

💖 `is_coderef()`

💖 `is_number()`

💖 `is_instance()`

💖 `is_regex()`

🌸 `assert_string()`

🌸 `assert_arrayref()`

🌸 `assert_hashref()`

🌸 `assert_coderef()`

🌸 `assert_number()`

🌸 `assert_instance()`

🌸 `assert_regex()`

✨ `filter_string()` ✨

🌸 `filter_arrayref()` 🌸

🦋 `filter_hashref()` 🦋

🎀 `filter_coderef()` 🎀

💅 `filter_number()` 💅

👑 `filter_instance()` 👑

🌈 `filter_regex()` 🌈