builtin(3p) Perl Programmers Reference Guide builtin(3p)

builtin(3p) Perl Programmers Reference Guide builtin(3p) #

builtin(3p) Perl Programmers Reference Guide builtin(3p)

NNAAMMEE #

 builtin - Perl pragma to import built-in utility functions

SSYYNNOOPPSSIISS #

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

DDEESSCCRRIIPPTTIIOONN #

 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 eexxppeerriimmeennttaall.

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

LLeexxiiccaall IImmppoorrtt This pragma module creates _l_e_x_i_c_a_l 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 ...

FFUUNNCCTTIIOONNSS #

ttrruuee $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".

ffaallssee $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".

iiss__bbooooll $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.

wweeaakkeenn 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".

uunnwweeaakkeenn unweaken($ref);

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

iiss__wweeaakk $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.

bblleesssseedd $str = blessed($ref);

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

rreeffaaddddrr $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.

rreeffttyyppee $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.

ccrreeaatteedd__aass__ssttrriinngg $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

ccrreeaatteedd__aass__nnuummbbeerr $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.

cceeiill $num = ceil($num);

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

fflloooorr $num = floor($num);

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

iinnddeexxeedd @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 _n_o_t 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.

ttrriimm $stripped = trim($string);

 Returns the input string with whitespace stripped from the beginning and
 end. ttrriimm(()) 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.

SSEEEE AALLSSOO #

 perlop, perlfunc, Scalar::Util

perl v5.36.3 2023-02-15 builtin(3p)