{
    "mode": "perldoc",
    "parameter": "Params::Validate",
    "section": "",
    "url": "https://www.chedong.com/phpMan.php/perldoc/Params%3A%3AValidate/json",
    "generated": "2026-06-12T05:53:42Z",
    "synopsis": "use Params::Validate qw(:all);\n# takes named params (hash or hashref)\nsub foo {\nvalidate(\n@, {\nfoo => 1,    # mandatory\nbar => 0,    # optional\n}\n);\n}\n# takes positional params\nsub bar {\n# first two are mandatory, third is optional\nvalidatepos( @, 1, 1, 0 );\n}\nsub foo2 {\nvalidate(\n@, {\nfoo =>\n# specify a type\n{ type => ARRAYREF },\nbar =>\n# specify an interface\n{ can => [ 'print', 'flush', 'frobnicate' ] },\nbaz => {\ntype      => SCALAR,     # a scalar ...\n# ... that is a plain integer ...\nregex     => qr/^\\d+$/,\ncallbacks => {           # ... and smaller than 90\n'less than 90' => sub { shift() < 90 },\n},\n}\n}\n);\n}\nsub callbackwithcustomerror {\nvalidate(\n@,\n{\nfoo => {\ncallbacks => {\n'is an integer' => sub {\nreturn 1 if $[0] =~ /^-?[1-9][0-9]*$/;\ndie \"$[0] is not a valid integer value\";\n},\n},\n}\n}\n);\n}\nsub withdefaults {\nmy %p = validate(\n@, {\n# required\nfoo => 1,\n# $p{bar} will be 99 if bar is not given. bar is now\n# optional.\nbar => { default => 99 }\n}\n);\n}\nsub poswithdefaults {\nmy @p = validatepos( @, 1, { default => 99 } );\n}\nsub setsoptionsoncall {\nmy %p = validatewith(\nparams => \\@,\nspec   => { foo => { type => SCALAR, default => 2 } },\nnormalizekeys => sub { $[0] =~ s/^-//; lc $[0] },\n);\n}",
    "sections": {
        "NAME": {
            "content": "Params::Validate - Validate method/function parameters\n",
            "subsections": []
        },
        "VERSION": {
            "content": "version 1.30\n",
            "subsections": []
        },
        "SYNOPSIS": {
            "content": "use Params::Validate qw(:all);\n\n# takes named params (hash or hashref)\nsub foo {\nvalidate(\n@, {\nfoo => 1,    # mandatory\nbar => 0,    # optional\n}\n);\n}\n\n# takes positional params\nsub bar {\n# first two are mandatory, third is optional\nvalidatepos( @, 1, 1, 0 );\n}\n\nsub foo2 {\nvalidate(\n@, {\nfoo =>\n# specify a type\n{ type => ARRAYREF },\nbar =>\n# specify an interface\n{ can => [ 'print', 'flush', 'frobnicate' ] },\nbaz => {\ntype      => SCALAR,     # a scalar ...\n# ... that is a plain integer ...\nregex     => qr/^\\d+$/,\ncallbacks => {           # ... and smaller than 90\n'less than 90' => sub { shift() < 90 },\n},\n}\n}\n);\n}\n\nsub callbackwithcustomerror {\nvalidate(\n@,\n{\nfoo => {\ncallbacks => {\n'is an integer' => sub {\nreturn 1 if $[0] =~ /^-?[1-9][0-9]*$/;\ndie \"$[0] is not a valid integer value\";\n},\n},\n}\n}\n);\n}\n\nsub withdefaults {\nmy %p = validate(\n@, {\n# required\nfoo => 1,\n# $p{bar} will be 99 if bar is not given. bar is now\n# optional.\nbar => { default => 99 }\n}\n);\n}\n\nsub poswithdefaults {\nmy @p = validatepos( @, 1, { default => 99 } );\n}\n\nsub setsoptionsoncall {\nmy %p = validatewith(\nparams => \\@,\nspec   => { foo => { type => SCALAR, default => 2 } },\nnormalizekeys => sub { $[0] =~ s/^-//; lc $[0] },\n);\n}\n",
            "subsections": []
        },
        "DESCRIPTION": {
            "content": "I would recommend you consider using Params::ValidationCompiler instead. That module, despite\nbeing pure Perl, is *significantly* faster than this one, at the cost of having to adopt a type\nsystem such as Specio, Type::Tiny, or the one shipped with Moose.\n\nThis module allows you to validate method or function call parameters to an arbitrary level of\nspecificity. At the simplest level, it is capable of validating the required parameters were\ngiven and that no unspecified additional parameters were passed in.\n\nIt is also capable of determining that a parameter is of a specific type, that it is an object\nof a certain class hierarchy, that it possesses certain methods, or applying validation\ncallbacks to arguments.\n\nEXPORT\nThe module always exports the \"validate()\" and \"validatepos()\" functions.\n\nIt also has an additional function available for export, \"validatewith\", which can be used to\nvalidate any type of parameters, and set various options on a per-invocation basis.\n\nIn addition, it can export the following constants, which are used as part of the type checking.\nThese are \"SCALAR\", \"ARRAYREF\", \"HASHREF\", \"CODEREF\", \"GLOB\", \"GLOBREF\", and \"SCALARREF\",\n\"UNDEF\", \"OBJECT\", \"BOOLEAN\", and \"HANDLE\". These are explained in the section on Type\nValidation.\n\nThe constants are available via the export tag \":types\". There is also an \":all\" tag which\nincludes all of the constants as well as the \"validationoptions()\" function.\n",
            "subsections": []
        },
        "PARAMETER VALIDATION": {
            "content": "The validation mechanisms provided by this module can handle both named or positional\nparameters. For the most part, the same features are available for each. The biggest difference\nis the way that the validation specification is given to the relevant subroutine. The other\ndifference is in the error messages produced when validation checks fail.\n\nWhen handling named parameters, the module will accept either a hash or a hash reference.\n\nSubroutines expecting named parameters should call the \"validate()\" subroutine like this:\n\nvalidate(\n@, {\nparameter1 => validation spec,\nparameter2 => validation spec,\n...\n}\n);\n\nSubroutines expecting positional parameters should call the \"validatepos()\" subroutine like\nthis:\n\nvalidatepos( @, { validation spec }, { validation spec } );\n\nMandatory/Optional Parameters\nIf you just want to specify that some parameters are mandatory and others are optional, this can\nbe done very simply.\n\nFor a subroutine expecting named parameters, you would do this:\n\nvalidate( @, { foo => 1, bar => 1, baz => 0 } );\n\nThis says that the \"foo\" and \"bar\" parameters are mandatory and that the \"baz\" parameter is\noptional. The presence of any other parameters will cause an error.\n\nFor a subroutine expecting positional parameters, you would do this:\n\nvalidatepos( @, 1, 1, 0, 0 );\n\nThis says that you expect at least 2 and no more than 4 parameters. If you have a subroutine\nthat has a minimum number of parameters but can take any maximum number, you can do this:\n\nvalidatepos( @, 1, 1, (0) x (@ - 2) );\n\nThis will always be valid as long as at least two parameters are given. A similar construct\ncould be used for the more complex validation parameters described further on.\n\nPlease note that this:\n\nvalidatepos( @, 1, 1, 0, 1, 1 );\n\nmakes absolutely no sense, so don't do it. Any zeros must come at the end of the validation\nspecification.\n\nIn addition, if you specify that a parameter can have a default, then it is considered optional.\n",
            "subsections": [
                {
                    "name": "Type Validation",
                    "content": "This module supports the following simple types, which can be exported as constants:\n\n*   SCALAR\n\nA scalar which is not a reference, such as 10 or 'hello'. A parameter that is undefined is\nnot treated as a scalar. If you want to allow undefined values, you will have to specify\n\"SCALAR | UNDEF\".\n\n*   ARRAYREF\n\nAn array reference such as \"[1, 2, 3]\" or \"\\@foo\".\n\n*   HASHREF\n\nA hash reference such as \"{ a => 1, b => 2 }\" or \"\\%bar\".\n\n*   CODEREF\n\nA subroutine reference such as \"\\&foosub\" or \"sub { print \"hello\" }\".\n\n*   GLOB\n\nThis one is a bit tricky. A glob would be something like *FOO, but not \"\\*FOO\", which is a\nglob reference. It should be noted that this trick:\n\nmy $fh = do { local *FH; };\n\nmakes $fh a glob, not a glob reference. On the other hand, the return value from\n\"Symbol::gensym\" is a glob reference. Either can be used as a file or directory handle.\n\n*   GLOBREF\n\nA glob reference such as \"\\*FOO\". See the GLOB entry above for more details.\n\n*   SCALARREF\n\nA reference to a scalar such as \"\\$x\".\n\n*   UNDEF\n\nAn undefined value\n\n*   OBJECT\n\nA blessed reference.\n\n*   BOOLEAN\n\nThis is a special option, and is just a shortcut for \"UNDEF | SCALAR\".\n\n*   HANDLE\n\nThis option is also special, and is just a shortcut for \"GLOB | GLOBREF\". However, it seems\nlikely that most people interested in either globs or glob references are likely to really\nbe interested in whether the parameter in question could be a valid file or directory\nhandle.\n\nTo specify that a parameter must be of a given type when using named parameters, do this:\n\nvalidate(\n@, {\nfoo => { type => SCALAR },\nbar => { type => HASHREF }\n}\n);\n\nIf a parameter can be of more than one type, just use the bitwise or (\"|\") operator to combine\nthem.\n\nvalidate( @, { foo => { type => GLOB | GLOBREF } );\n\nFor positional parameters, this can be specified as follows:\n\nvalidatepos( @, { type => SCALAR | ARRAYREF }, { type => CODEREF } );\n"
                },
                {
                    "name": "Interface Validation",
                    "content": "To specify that a parameter is expected to have a certain set of methods, we can do the\nfollowing:\n\nvalidate(\n@, {\nfoo =>\n# just has to be able to ->bar\n{ can => 'bar' }\n}\n);\n\n... or ...\n\nvalidate(\n@, {\nfoo =>\n# must be able to ->bar and ->print\n{ can => [qw( bar print )] }\n}\n);\n"
                },
                {
                    "name": "Class Validation",
                    "content": "A word of warning. When constructing your external interfaces, it is probably better to specify\nwhat methods you expect an object to have rather than what class it should be of (or a child\nof). This will make your API much more flexible.\n\nWith that said, if you want to validate that an incoming parameter belongs to a class (or child\nclass) or classes, do:\n\nvalidate(\n@,\n{ foo => { isa => 'My::Frobnicator' } }\n);\n\n... or ...\n\nvalidate(\n@,\n# must be both, not either!\n{ foo => { isa => [qw( My::Frobnicator IO::Handle )] } }\n);\n"
                },
                {
                    "name": "Regex Validation",
                    "content": "If you want to specify that a given parameter must match a specific regular expression, this can\nbe done with \"regex\" spec key. For example:\n\nvalidate(\n@,\n{ foo => { regex => qr/^\\d+$/ } }\n);\n\nThe value of the \"regex\" key may be either a string or a pre-compiled regex created via \"qr\".\n\nIf the value being checked against a regex is undefined, the regex is explicitly checked against\nthe empty string ('') instead, in order to avoid \"Use of uninitialized value\" warnings.\n\nThe \"Regexp::Common\" module on CPAN is an excellent source of regular expressions suitable for\nvalidating input.\n"
                },
                {
                    "name": "Callback Validation",
                    "content": "If none of the above are enough, it is possible to pass in one or more callbacks to validate the\nparameter. The callback will be given the value of the parameter as its first argument. Its\nsecond argument will be all the parameters, as a reference to either a hash or array. Callbacks\nare specified as hash reference. The key is an id for the callback (used in error messages) and\nthe value is a subroutine reference, such as:\n\nvalidate(\n@,\n{\nfoo => {\ncallbacks => {\n'smaller than a breadbox' => sub { shift() < $breadbox },\n'green or blue'           => sub {\nreturn 1 if $[0] eq 'green' || $[0] eq 'blue';\ndie \"$[0] is not green or blue!\";\n}\n}\n}\n}\n);\n\nvalidate(\n@, {\nfoo => {\ncallbacks => {\n'bigger than baz' => sub { $[0] > $[1]->{baz} }\n}\n}\n}\n);\n\nThe callback should return a true value if the value is valid. If not, it can return false or\ndie. If you return false, a generic error message will be thrown by \"Params::Validate\".\n\nIf your callback dies instead you can provide a custom error message. If the callback dies with\na plain string, this string will be appended to an exception message generated by\n\"Params::Validate\". If the callback dies with a reference (blessed or not), then this will be\nrethrown as-is by \"Params::Validate\".\n"
                },
                {
                    "name": "Untainting",
                    "content": "If you want values untainted, set the \"untaint\" key in a spec hashref to a true value, like\nthis:\n\nmy %p = validate(\n@, {\nfoo => { type => SCALAR, untaint => 1 },\nbar => { type => ARRAYREF }\n}\n);\n\nThis will untaint the \"foo\" parameter if the parameters are valid.\n\nNote that untainting is only done if *all parameters* are valid. Also, only the return values\nare untainted, not the original values passed into the validation function.\n\nAsking for untainting of a reference value will not do anything, as \"Params::Validate\" will only\nattempt to untaint the reference itself.\n\nMandatory/Optional Revisited\nIf you want to specify something such as type or interface, plus the fact that a parameter can\nbe optional, do this:\n\nvalidate(\n@, {\nfoo => { type => SCALAR },\nbar => { type => ARRAYREF, optional => 1 }\n}\n);\n\nor this for positional parameters:\n\nvalidatepos(\n@,\n{ type => SCALAR },\n{ type => ARRAYREF, optional => 1 }\n);\n\nBy default, parameters are assumed to be mandatory unless specified as optional.\n"
                },
                {
                    "name": "Dependencies",
                    "content": "It also possible to specify that a given optional parameter depends on the presence of one or\nmore other optional parameters.\n\nvalidate(\n@, {\nccnumber => {\ntype     => SCALAR,\noptional => 1,\ndepends  => [ 'ccexpiration', 'ccholdername' ],\n},\nccexpiration  => { type => SCALAR, optional => 1 },\nccholdername => { type => SCALAR, optional => 1 },\n}\n);\n\nIn this case, \"ccnumber\", \"ccexpiration\", and \"ccholdername\" are all optional. However, if\n\"ccnumber\" is provided, then \"ccexpiration\" and \"ccholdername\" must be provided as well.\n\nThis allows you to group together sets of parameters that all must be provided together.\n\nThe \"validatepos()\" version of dependencies is slightly different, in that you can only depend\non one other parameter. Also, if for example, the second parameter 2 depends on the fourth\nparameter, then it implies a dependency on the third parameter as well. This is because if the\nfourth parameter is required, then the user must also provide a third parameter so that there\ncan be four parameters in total.\n\n\"Params::Validate\" will die if you try to depend on a parameter not declared as part of your\nparameter specification.\n"
                },
                {
                    "name": "Specifying defaults",
                    "content": "If the \"validate()\" or \"validatepos()\" functions are called in a list context, they will return\na hash or containing the original parameters plus defaults as indicated by the validation spec.\n\nIf the function is not called in a list context, providing a default in the validation spec\nstill indicates that the parameter is optional.\n\nThe hash or array returned from the function will always be a copy of the original parameters,\nin order to leave @ untouched for the calling function.\n\nSimple examples of defaults would be:\n\nmy %p = validate( @, { foo => 1, bar => { default => 99 } } );\n\nmy @p = validatepos( @, 1, { default => 99 } );\n\nIn scalar context, a hash reference or array reference will be returned, as appropriate.\n"
                }
            ]
        },
        "USAGE NOTES": {
            "content": "",
            "subsections": [
                {
                    "name": "Validation failure",
                    "content": "By default, when validation fails \"Params::Validate\" calls \"Carp::confess()\". This can be\noverridden by setting the \"onfail\" option, which is described in the \"GLOBAL\" OPTIONS section.\n"
                },
                {
                    "name": "Method calls",
                    "content": "When using this module to validate the parameters passed to a method call, you will probably\nwant to remove the class/object from the parameter list before calling \"validate()\" or\n\"validatepos()\". If your method expects named parameters, then this is necessary for the\n\"validate()\" function to actually work, otherwise @ will not be usable as a hash, because it\nwill first have your object (or class) followed by a set of keys and values.\n\nThus the idiomatic usage of \"validate()\" in a method call will look something like this:\n\nsub method {\nmy $self = shift;\n\nmy %params = validate(\n@, {\nfoo => 1,\nbar => { type => ARRAYREF },\n}\n);\n}\n"
                },
                {
                    "name": "Speeding Up Validation",
                    "content": "In most cases, the validation spec will remain the same for each call to a subroutine. In that\ncase, you can speed up validation by defining the validation spec just once, rather than on each\ncall to the subroutine:\n\nmy %spec = ( ... );\nsub foo {\nmy %params = validate( @, \\%spec );\n}\n\nYou can also use the \"state\" feature to do this:\n\nuse feature 'state';\n\nsub foo {\nstate $spec = { ... };\nmy %params = validate( @, $spec );\n}\n\n\"GLOBAL\" OPTIONS\nBecause the API for the \"validate()\" and \"validatepos()\" functions does not make it possible to\nspecify any options other than the validation spec, it is possible to set some options as\npseudo-'globals'. These allow you to specify such things as whether or not the validation of\nnamed parameters should be case sensitive, for one example.\n\nThese options are called pseudo-'globals' because these settings are only applied to calls\noriginating from the package that set the options.\n\nIn other words, if I am in package \"Foo\" and I call \"validationoptions()\", those options are\nonly in effect when I call \"validate()\" from package \"Foo\".\n\nWhile this is quite different from how most other modules operate, I feel that this is necessary\nin able to make it possible for one module/application to use Params::Validate while still using\nother modules that also use Params::Validate, perhaps with different options set.\n\nThe downside to this is that if you are writing an app with a standard calling style for all\nfunctions, and your app has ten modules, each module must include a call to\n\"validationoptions()\". You could of course write a module that all your modules use which uses\nvarious trickery to do this when imported.\n"
                },
                {
                    "name": "Options",
                    "content": "*   normalizekeys => $callback\n\nThis option is only relevant when dealing with named parameters.\n\nThis callback will be used to transform the hash keys of both the parameters and the\nparameter spec when \"validate()\" or \"validatewith()\" are called.\n\nAny alterations made by this callback will be reflected in the parameter hash that is\nreturned by the validation function. For example:\n\nsub foo {\nreturn validatewith(\nparams => \\@,\nspec   => { foo => { type => SCALAR } },\nnormalizekeys =>\nsub { my $k = shift; $k =~ s/^-//; return uc $k },\n);\n\n}\n\n%p = foo( foo => 20 );\n\n# $p{FOO} is now 20\n\n%p = foo( -fOo => 50 );\n\n# $p{FOO} is now 50\n\nThe callback must return a defined value.\n\nIf a callback is given then the deprecated \"ignorecase\" and \"stripleading\" options are\nignored.\n\n*   allowextra => $boolean\n\nIf true, then the validation routine will allow extra parameters not named in the validation\nspecification. In the case of positional parameters, this allows an unlimited number of\nmaximum parameters (though a minimum may still be set). Defaults to false.\n\n*   onfail => $callback\n\nIf given, this callback will be called whenever a validation check fails. It will be called\nwith a single parameter, which will be a string describing the failure. This is useful if\nyou wish to have this module throw exceptions as objects rather than as strings, for\nexample.\n\nThis callback is expected to \"die()\" internally. If it does not, the validation will proceed\nonwards, with unpredictable results.\n\nThe default is to simply use the Carp module's \"confess()\" function.\n\n*   stackskip => $number\n\nThis tells Params::Validate how many stack frames to skip when finding a subroutine name to\nuse in error messages. By default, it looks one frame back, at the immediate caller to\n\"validate()\" or \"validatepos()\". If this option is set, then the given number of frames are\nskipped instead.\n\n*   ignorecase => $boolean\n\nDEPRECATED\n\nThis is only relevant when dealing with named parameters. If it is true, then the validation\ncode will ignore the case of parameter names. Defaults to false.\n\n*   stripleading => $characters\n\nDEPRECATED\n\nThis too is only relevant when dealing with named parameters. If this is given then any\nparameters starting with these characters will be considered equivalent to parameters\nwithout them entirely. For example, if this is specified as '-', then \"-foo\" and \"foo\" would\nbe considered identical.\n"
                }
            ]
        },
        "PER-INVOCATION OPTIONS": {
            "content": "The \"validatewith()\" function can be used to set the options listed above on a per-invocation\nbasis. For example:\n\nmy %p = validatewith(\nparams => \\@,\nspec   => {\nfoo => { type    => SCALAR },\nbar => { default => 10 }\n},\nallowextra => 1,\n);\n\nIn addition to the options listed above, it is also possible to set the option \"called\", which\nshould be a string. This string will be used in any error messages caused by a failure to meet\nthe validation spec.\n\nThis subroutine will validate named parameters as a hash if the \"spec\" parameter is a hash\nreference. If it is an array reference, the parameters are assumed to be positional.\n\nmy %p = validatewith(\nparams => \\@,\nspec   => {\nfoo => { type    => SCALAR },\nbar => { default => 10 }\n},\nallowextra => 1,\ncalled      => 'The Quux::Baz class constructor',\n);\n\nmy @p = validatewith(\nparams => \\@,\nspec   => [\n{ type    => SCALAR },\n{ default => 10 }\n],\nallowextra => 1,\ncalled      => 'The Quux::Baz class constructor',\n);\n",
            "subsections": []
        },
        "DISABLING VALIDATION": {
            "content": "If the environment variable \"PERLNOVALIDATION\" is set to something true, then validation is\nturned off. This may be useful if you only want to use this module during development but don't\nwant the speed hit during production.\n\nThe only error that will be caught will be when an odd number of parameters are passed into a\nfunction/method that expects a hash.\n\nIf you want to selectively turn validation on and off at runtime, you can directly set the\n$Params::Validate::NOVALIDATION global variable. It is strongly recommended that you localize\nany changes to this variable, because other modules you are using may expect validation to be on\nwhen they execute. For example:\n\n{\nlocal $Params::Validate::NOVALIDATION = 1;\n\n# no error\nfoo( bar => 2 );\n}\n\n# error\nfoo( bar => 2 );\n\nsub foo {\nmy %p = validate( @, { foo => 1 } );\n...;\n}\n\nBut if you want to shoot yourself in the foot and just turn it off, go ahead!\n",
            "subsections": []
        },
        "SPECIFYING AN IMPLEMENTATION": {
            "content": "This module ships with two equivalent implementations, one in XS and one in pure Perl. By\ndefault, it will try to load the XS version and fall back to the pure Perl implementation as\nneeded. If you want to request a specific version, you can set the\n\"PARAMSVALIDATEIMPLEMENTATION\" environment variable to either \"XS\" or \"PP\". If the\nimplementation you ask for cannot be loaded, then this module will die when loaded.\n",
            "subsections": []
        },
        "TAINT MODE": {
            "content": "The XS implementation of this module has some problems Under taint mode with versions of Perl\nbefore 5.14. If validation *fails*, then instead of getting the expected error message you'll\nget a message like \"Insecure dependency in evalsv\". This can be worked around by either\nuntainting the arguments yourself, using the pure Perl implementation, or upgrading your Perl.\n",
            "subsections": []
        },
        "LIMITATIONS": {
            "content": "Right now there is no way (short of a callback) to specify that something must be of one of a\nlist of classes, or that it must possess one of a list of methods. If this is desired, it can be\nadded in the future.\n\nIdeally, there would be only one validation function. If someone figures out how to do this,\nplease let me know.\n",
            "subsections": []
        },
        "SUPPORT": {
            "content": "Bugs may be submitted at <https://rt.cpan.org/Public/Dist/Display.html?Name=Params-Validate> or\nvia email to bug-params-validate@rt.cpan.org <mailto:bug-params-validate@rt.cpan.org>.\n\nI am also usually active on IRC as 'autarch' on \"irc://irc.perl.org\".\n",
            "subsections": []
        },
        "SOURCE": {
            "content": "The source code repository for Params-Validate can be found at\n<https://github.com/houseabsolute/Params-Validate>.\n",
            "subsections": []
        },
        "DONATIONS": {
            "content": "If you'd like to thank me for the work I've done on this module, please consider making a\n\"donation\" to me via PayPal. I spend a lot of free time creating free software, and would\nappreciate any support you'd care to offer.\n\nPlease note that I am not suggesting that you must do this in order for me to continue working\non this particular software. I will continue to do so, inasmuch as I have in the past, for as\nlong as it interests me.\n\nSimilarly, a donation made in this way will probably not make me work on this software much\nmore, unless I get so many donations that I can consider working on free software full time\n(let's all have a chuckle at that together).\n\nTo donate, log into PayPal and send money to autarch@urth.org, or use the button at\n<https://www.urth.org/fs-donation.html>.\n",
            "subsections": []
        },
        "AUTHORS": {
            "content": "*   Dave Rolsky <autarch@urth.org>\n\n*   Ilya Martynov <ilya@martynov.org>\n",
            "subsections": []
        },
        "CONTRIBUTORS": {
            "content": "*   Andy Grundman <andyg@activestate.com>\n\n*   Diab Jerius <djerius@cfa.harvard.edu>\n\n*   E. Choroba <choroba@matfyz.cz>\n\n*   Ivan Bessarabov <ivan@bessarabov.ru>\n\n*   J.R. Mash <jmash.code@gmail.com>\n\n*   Karen Etheridge <ether@cpan.org>\n\n*   Noel Maddy <zhtwnpanta@gmail.com>\n\n*   Olivier Mengué <dolmen@cpan.org>\n\n*   Tony Cook <tony@develop-help.com>\n\n*   Vincent Pit <perl@profvince.com>\n",
            "subsections": []
        },
        "COPYRIGHT AND LICENSE": {
            "content": "This software is Copyright (c) 2001 - 2020 by Dave Rolsky and Ilya Martynov.\n\nThis is free software, licensed under:\n\nThe Artistic License 2.0 (GPL Compatible)\n\nThe full text of the license can be found in the LICENSE file included with this distribution.\n",
            "subsections": []
        }
    },
    "summary": "Params::Validate - Validate method/function parameters",
    "flags": [],
    "examples": [],
    "see_also": []
}