--- name: "Data::Types" section: "3pm" platform: "linux" package: "libdata-types-perl" version: "0.17-1" release: "Debian 13 (Trixie)" platforms: ["linux"] url: "https://new.carta.tech/Data::Types" --- # Data::Types(3pm) Validate and convert data types. ## NAME Data::Types - Validate and convert data types. ## SYNOPSIS ``` use Data::Types qw(:all); my $whole = 4.5; $whole = to_whole($whole) unless is_whole($whole); my $int = 1.2; $int = to_int($int) unless is_int($int); my $decimal = '1.2foo'; $decimal = to_decimal($decimal) unless is_decimal($decimal); my $real = '1.2foo'; $real = to_real($real) unless is_real($real); my $float = '1.2foo'; $float = to_float($float) unless is_float($float); my $string = []; $string = to_string($string) unless is_string($string); ``` ## DESCRIPTION This module exports a number of functions that are useful for validating and converting data types. It is intended for use in applications where data types are more important than they typically are in Perl -- e.g., database applications. ## EXPORT No functions are exported by default, though each function may be exported explicitly (see "FUNCTIONS" below, for a list of functions available for export). The following export tags are supported: - :whole Exports **is\_whole()** and **to\_whole()**. - :count Exports **is\_count()** and **to\_count()**. - :int Exports **is\_int()** and **to\_int()**. - :decimal Exports **is\_decimal()** and **to\_decimal()**. - :real Exports **is\_real()** and **to\_real()**. - :float Exports **is\_float()** and **to\_float()**. - :string Exports **is\_string()** and **to\_string()**. - :is Exports all validation functions: **is\_whole()**, **is\_int()**, **is\_real()**, **is\_decimal()**, **is\_float()**, and **is\_string()**. - :to Exports all conversion functions: **to\_whole()**, **to\_int()**, **to\_real()**, **to\_decimal()**, **to\_float()**, and **to\_string()**. - :all Exports all functions. ## FUNCTIONS ### is\_whole ``` my $bool = is_whole($val); ``` Returns true if `$val` is a whole number (including 0), and false if it is not. The regular expression used to test the wholeness of `$val` is `"/^\d+$/"`. ``` my $bool = is_whole(1); # Returns true. $bool = is_whole(-1); # Returns false. $bool = is_whole(0); # Returns true. ``` ### to\_whole ``` my $whole = to_whole($val); ``` Converts `$val` to a whole number and returns it. Numbers will be rounded to the nearest whole. If `$val` is a mixture of numbers and letters, **to\_whole()** will extract the first decimal number it finds and convert that number to a whole number. ``` my $whole = to_whole(10); # Returns 10. $whole = to_whole(0); # Returns 0. $whole = to_whole(.22); # Returns 0. $whole = to_whole(-2); # Returns undef. $whole = to_whole('foo3.56'); # Returns 4. $whole = to_whole('foo'); # Returns undef. ``` ### is\_count ``` my $bool = is_count($val); ``` Returns true if `$val` is a counting number (1, 2, 3, ...), and false if it is not. The regular expression used to test whether `$val` is a counting number is `"/^\d+$/"`. ``` my $bool = is_count(1); # Returns true. $bool = is_count(-1); # Returns false. $bool = is_count(0); # Returns false. ``` ### to\_count ``` my $count = to_count($val); ``` Converts `$val` to a counting number and returns it. Numbers will be rounded to the nearest counting number. Note that since 0 (zero) is not considered a counting number by this module, it will not be returned. If `$val` is a mixture of numbers and letters, **to\_count()** will extract the first decimal number it finds and convert that number to a counting number. ``` my $count = to_count(10); # Returns 10. $count = to_count(0); # Returns undef. $count = to_count(.22); # Returns undef (rounded down to 0). $count = to_count(-2); # Returns undef. $count = to_count('foo3.56'); # Returns 4. $count = to_count('foo'); # Returns undef. ``` ### is\_int ``` my $bool = is_int($val); ``` Returns true if `$val` is an integer, and false if it is not. Numbers may be preceded by a plus or minus sign. The regular expression used to test for an integer in `$val` is `"/^[+-]?\d+$/"`. ``` my $bool = is_int(0); # Returns true. $bool = is_int(22); # Returns true. $bool = is_int(-22); # Returns true. $bool = is_int(3.2); # Returns false. ``` ### to\_int ``` my $int = to_int($val); ``` Converts `$val` to an integer. If `$val` is a decimal number, it will be rounded to the nearest integer. If `$val` is a mixture of numbers and letters, **to\_int()** will extract the first decimal number it finds and convert that number to an integer. ``` my $int = to_int(10.5); # Returns 10. $int = to_int(10.51); # Returns 11. $int = to_int(-0.22); # Returns 0. $int = to_int(-6.51); # Returns 7. $int = to_int('foo'); # Returns undef. ``` ### is\_decimal ``` my $bool = is_decimal($val); ``` Returns true if `$val` is a decimal number, and false if it is not. Numbers may be preceded by a plus or minus sign. The regular expression used to test `$val` is `"/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/"`. ``` my $bool = is_decimal(10) # Returns true. $bool = is_decimal(10.8) # Returns true. $bool = is_decimal(-33.48) # Returns true. $bool = is_decimal(1.23e99) # Returns false. ``` ### to\_decimal ``` my $dec = to_decimal($val); $dec = to_decimal($val, $precision); ``` Converts `$val` to a decimal number. The optional second argument sets the precision of the number. The default precision is 5. If `$val` is a mixture of numbers and letters, **to\_decimal()** will extract the first decimal number it finds. ``` my $dec = to_decimal(0); # Returns 0.00000. $dec = to_decimal(10.5); # Returns 10.5. $dec = to_decimal(10.500009); # Returns 10.50001. $dec = to_decimal(10.500009, 7); # Returns 10.5000090. $dec = to_decimal('foo10.3') # Returns 10.30000. $dec = to_decimal('foo-4.9') # Returns -4.90000. $dec = to_decimal('foo') # Returns undef. ``` ### is\_real ``` my $bool = is_real($val); ``` Returns true if `$val` is a real number, and false if it is not. **Note:** This function is currently equivalent to **is\_decimal()**, since this module cannot identify non-decimal real numbers (e.g., irrational numbers). This implementation may change in the future. ### to\_real ``` my $real = to_real($val); $real = to_real($val, $precision); ``` Converts `$val` to a real number. **Note:** Currently, this function is the equivalent of **to\_decimal()**, since this module cannot identify non-decimal real numbers (e.g., irrational numbers). This implementation may change in the future. ### is\_float ``` my $bool = is_float($val); ``` Returns true if `$val` is a float, and false if it is not. The regular expression used to test `$val` is `"/^([+-]?)(?=[0-9]|\.[0-9])[0-9]*(\.[0-9]*)?([Ee]([+-]?[0-9]+))?$/"`. ``` my $bool = is_float(30); # Returns true. $bool = is_float(1.23e99); # Returns true. $bool = is_float('foo'); # Returns false. ``` ### to\_float ``` my $dec = to_float($val); $dec = to_float($val, $precision); ``` Converts `$val` to a float. The optional second argument sets the precision of the number. The default precision is 5. If `$val` is a mixture of numbers and letters, **to\_float()** will extract the first float it finds. ``` my $float = to_float(1.23); # Returns 1.23000. $float = to_float(1.23e99); # Returns 1.23000e+99. $float = to_float(1.23e99, 1); # Returns 1.2e+99. $float = to_float('foo-1.23'); # Returns -1.23000. $float = to_float('ick_1.23e99foo'); # Returns 1.23000e+99. ``` ### is\_string ``` my $bool = is_string($val); ``` Returns true if `$val` is a string, and false if it is not. All defined non-references are considered strings. ``` my $bool = is_string('foo'); # Returns true. $bool = is_string(20001); # Returns true. $bool = is_string([]); # Returns false. $bool = is_string(undef); # Returns false. ``` ### to\_string ``` my $string = to_string($val); $string = to_string($val, $length); ``` Converts `$val` into a string. If `$val` is a reference, the string value of the reference will be returned. Such a value may be a memory address, or some other value, if the stringification operator has been overridden for the object stored in `$val`. If the optional second argument `$length` is passed, **to\_string()** will truncate the string to that length. If `$length` is 0 (zero), it will not limit the length of the return string. If `$val` is undefined, **to\_string()** will return undef. ``` my $string = to_string('foo'); # Returns 'foo'. $string = to_string([]); # Returns 'ARRAY(0x101bec14)'. $string = to_string(undef); # Returns undef. $string = to_string('hello', 4); # Returns 'hell'. ``` ## SUPPORT This module is stored in an open GitHub repository \. Feel free to fork and contribute! Please file bug reports via GitHub Issues \ or by sending mail to bug-Data-Types@rt.cpan.org \. Patches against Class::Meta are welcome. Please send bug reports to \. ## AUTHOR David E. Wheeler \ Currently maintained by Mohammad S Anwar `""` ## SEE ALSO perlfaq4 lists the most of the regular expressions used to identify the different numeric types used in this module. String::Checker also does some data type validation. String::Scanf reimplements the C `"sscanf()"` function in perl, and also does data type validation and conversion. Regexp::Common contains many useful common regular expressions (surprise!), including some that can be used to identify data types. Arthur Bergman's types pragma, offers compile-time data types for Perl 5.8.0. The data types include int, float, and string. I highly recommend using this pragma for fast, static data types. ## COPYRIGHT AND LICENSE Copyright (c) 2002-2011, David E. Wheeler. Some Rights Reserved. This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.