NAME

       builtin - Perl pragma to import built-in utility functions

SYNOPSIS

           use builtin qw(
               true false is_bool
               weaken unweaken is_weak
               blessed refaddr reftype
               created_as_string created_as_number
               ceil floor
               trim
           );

DESCRIPTION

       Perl provides several utility functions in the "builtin" package. These are plain
       functions, and look and behave just like regular user-defined functions do. They do not
       provide new syntax or require special parsing. These functions are always present in the
       interpreter and can be called at any time by their fully-qualified names. By default they
       are not available as short names, but can be requested for convenience.

       Individual named functions can be imported by listing them as import parameters on the
       "use" statement for this pragma.

       The overall "builtin" mechanism, as well as every individual function it provides, are
       currently experimental.

       Warning:  At present, the entire "builtin" namespace is experimental.  Calling functions
       in it will trigger warnings of the "experimental::builtin" category.

   Lexical Import
       This pragma module creates lexical aliases in the currently-compiling scope to these
       builtin functions. This is similar to the lexical effect of other pragmas such as strict
       and feature.

           sub classify
           {
               my $val = shift;

               use builtin 'is_bool';
               return is_bool($val) ? "boolean" : "not a boolean";
           }

           # the is_bool() function is no longer visible here
           # but may still be called by builtin::is_bool()

       Because these functions are imported lexically, rather than by package symbols, the user
       does not need to take any special measures to ensure they don't accidentally appear as
       object methods from a class.

           package An::Object::Class {
               use builtin 'true', 'false';
               ...
           }

           # does not appear as a method
           An::Object::Class->true;

           # Can't locate object method "true" via package "An::Object::Class"
           #   at ...

FUNCTIONS

   true
           $val = true;

       Returns the boolean truth value. While any scalar value can be tested for truth and most
       defined, non-empty and non-zero values are considered "true" by perl, this one is special
       in that "is_bool" considers it to be a distinguished boolean value.

       This gives an equivalent value to expressions like "!!1" or "!0".

   false
           $val = false;

       Returns the boolean fiction value. While any non-true scalar value is considered "false"
       by perl, this one is special in that "is_bool" considers it to be a distinguished boolean
       value.

       This gives an equivalent value to expressions like "!!0" or "!1".

   is_bool
           $bool = is_bool($val);

       Returns true when given a distinguished boolean value, or false if not. A distinguished
       boolean value is the result of any boolean-returning builtin function (such as "true" or
       "is_bool" itself), boolean-returning operator (such as the "eq" or "==" comparison tests
       or the "!" negation operator), or any variable containing one of these results.

       This function used to be named "isbool". A compatibility alias is provided currently but
       will be removed in a later version.

   weaken
           weaken($ref);

       Weakens a reference. A weakened reference does not contribute to the reference count of
       its referent. If only weakened references to a referent remain, it will be disposed of,
       and all remaining weak references to it will have their value set to "undef".

   unweaken
           unweaken($ref);

       Strengthens a reference, undoing the effects of a previous call to "weaken".

   is_weak
           $bool = is_weak($ref);

       Returns true when given a weakened reference, or false if not a reference or not weak.

       This function used to be named "isweak". A compatibility alias is provided currently but
       will be removed in a later version.

   blessed
           $str = blessed($ref);

       Returns the package name for an object reference, or "undef" for a non-reference or
       reference that is not an object.

   refaddr
           $num = refaddr($ref);

       Returns the memory address for a reference, or "undef" for a non-reference.  This value is
       not likely to be very useful for pure Perl code, but is handy as a means to test for
       referential identity or uniqueness.

   reftype
           $str = reftype($ref);

       Returns the basic container type of the referent of a reference, or "undef" for a non-
       reference. This is returned as a string in all-capitals, such as "ARRAY" for array
       references, or "HASH" for hash references.

   created_as_string
           $bool = created_as_string($val);

       Returns a boolean representing if the argument value was originally created as a string.
       It will return true for any scalar expression whose most recent assignment or modification
       was of a string-like nature - such as assignment from a string literal, or the result of a
       string operation such as concatenation or regexp. It will return false for references
       (including any object), numbers, booleans and undef.

       It is unlikely that you will want to use this for regular data validation within Perl, as
       it will not return true for regular numbers that are still perfectly usable as strings,
       nor for any object reference - especially objects that overload the stringification
       operator in an attempt to behave more like strings. For example

           my $val = URI->new( "https://metacpan.org/" );

           if( created_as_string $val ) { ... }    # this will not execute

   created_as_number
           $bool = created_as_number($val);

       Returns a boolean representing if the argument value was originally created as a number.
       It will return true for any scalar expression whose most recent assignment or modification
       was of a numerical nature - such as assignment from a number literal, or the result of a
       numerical operation such as addition. It will return false for references (including any
       object), strings, booleans and undef.

       It is unlikely that you will want to use this for regular data validation within Perl, as
       it will not return true for regular strings of decimal digits that are still perfectly
       usable as numbers, nor for any object reference - especially objects that overload the
       numification operator in an attempt to behave more like numbers. For example

           my $val = Math::BigInt->new( 123 );

           if( created_as_number $val ) { ... }    # this will not execute

       While most Perl code should operate on scalar values without needing to know their
       creation history, these two functions are intended to be used by data serialisation
       modules such as JSON encoders or similar situations, where language interoperability
       concerns require making a distinction between values that are fundamentally stringlike
       versus numberlike in nature.

   ceil
           $num = ceil($num);

       Returns the smallest integer value greater than or equal to the given numerical argument.

   floor
           $num = floor($num);

       Returns the largest integer value less than or equal to the given numerical argument.

   indexed
           @ivpairs = indexed(@items)

       Returns an even-sized list of number/value pairs, where each pair is formed of a number
       giving an index in the original list followed by the value at that position in it.  I.e.
       returns a list twice the size of the original, being equal to

           (0, $items[0], 1, $items[1], 2, $items[2], ...)

       Note that unlike the core "values" function, this function returns copies of its original
       arguments, not aliases to them. Any modifications of these copies are not reflected in
       modifications to the original.

           my @x = ...;
           $_++ for indexed @x;  # The @x array remains unaffected

       This function is primarily intended to be useful combined with multi-variable "foreach"
       loop syntax; as

           foreach my ($index, $value) (indexed LIST) {
               ...
           }

       In scalar context this function returns the size of the list that it would otherwise have
       returned, and provokes a warning in the "scalar" category.

   trim
           $stripped = trim($string);

       Returns the input string with whitespace stripped from the beginning and end. trim() will
       remove these characters:

       " ", an ordinary space.

       "\t", a tab.

       "\n", a new line (line feed).

       "\r", a carriage return.

       and all other Unicode characters that are flagged as whitespace.  A complete list is in
       "Whitespace" in perlrecharclass.

           $var = "  Hello world   ";            # "Hello world"
           $var = "\t\t\tHello world";           # "Hello world"
           $var = "Hello world\n";               # "Hello world"
           $var = "\x{2028}Hello world\x{3000}"; # "Hello world"

       "trim" is equivalent to:

           $str =~ s/\A\s+|\s+\z//urg;

       For Perl versions where this feature is not available look at the String::Util module for
       a comparable implementation.

SEE ALSO

       perlop, perlfunc, Scalar::Util