Coercions in Perl

In Perl, there are values of different types like strings, integers, rational numbers, and more. Coercion is responsible for converting one data type of data or object to another, behind the scenes where we magically just get what we want. It generally refers to “implicit type conversion” which is also one of the ways of changing an entity of one data type into another.

The most common form of coercion is the overload pragma, and its string overloading in Perl programming. In this case, our object is automatically coerced into a string (within Perl itself).
The type of coercion intended for high order coercion is the Params::Coerce which is mainly used in subroutine and method parameters.

Types of Coercions

The types of coercion are explained below:

  • Boolean Coercion: Boolean coercion is useful to test the truthiness of value just like in an if or while condition. All the numeric 0, undef, the empty string, and the string ‘0’ evaluate as false values. All the other values including strings which are numerically equal to zero (like ‘0.0’, ‘0e’ and ‘0 but true’)- evaluate as true values.
    When a scalar consists of both string and numeric components, Perl preferably checks the string component for Boolean truth. ‘0 but true’ evaluates to zero numerically, but is not an empty string, hence it gets evaluated as a true value in a Boolean context.

    Example:

    say ?^True; # Falsesay ?^'';   # Truesay ?^0;    # Truesay ?^42;   # False

    (The ? prefix operator is the Boolean coercion operator. It converts its operand to a Boolean value.)

  • String Coercion: String coercion comes into action when we use string operators like comparisons (eq and cmp), concatenation, split, substr, and regular expressions, and also while using a value or an expression as a hash key. The undefined value is then stringified to an empty string but produces a “use of uninitialized value” warning. Numbers stringify to string which contains their values. (stringify = to return a string)

    Example:



    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    use strict;
    use warnings;
    my $x = "4T"; # string
    my $y = 3;    # integer
    my $z = $x.$y;
    print $z;     # coerced

    chevron_right

    
    

    Output:

    4T3
  • Numeric Coercion: Numeric coercion occurs when we use a numeric comparison operator such as == and <=>, while performing mathematical operations or while using an expression or a value as an array or list index. The undefined value then numifies to zero and gives us a “Use of uninitialized value” warning. The strings which do not start with any numeric portion numify to zero and give us a warning of “Argument isn’t numeric”. And the ones which begin with character allowed in numeric literals numify to the values specified and produce no warning. (numify = to return a number).
    There’s also a function in Perl function which uses the same parsing rules as the Perl grammar to extract a number from a string that is looks_like_number() which is included in the core module Scalar::Util.

    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    my $a = "23B";
    $a +=0;
      
    # string part has been removed automatically.
    print $a

    chevron_right

    
    

    Output:

    23
  • Reference Coercion: When we use a dereferencing operation on a non-reference, it turns a value into a reference. This process is known as Autovivification. This process comes handy while manipulating nested data structures.
    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    my %users;
    $users{John}{id} = 128;
    $users{Thomas}{id} = 129;

    chevron_right

    
    

    Explanation: As we can see in this that the hash doesn’t contain values for John and Thomas but Perl has helpfully created hash references for them, assigning each of them a key/value pair keyed on id.

  • Cached Coercions: The internal representation of values in Perl stores both string and numeric values. Like when we stringify a value, it does not replace the numeric value rather it adds a stringified value to the internal representation which later consists of both the components. Similarly when we numify a string value, it populates the numeric value and leaves the string component untouched.
    For example: Certain Perl operators often prefer to use one value over the other (just like Boolean checks prefer strings). If there’s a value which has cached representation in a form that we don’t expect, then relying on an implicit conversion may produce some surprising results. Knowing how this occurs might help us to help us diagnose some odd situation.

Dualvars

Perl has a multi-component nature which is available to user in the form of dualvars. The function dualvar() is provided by the core module Scalar :: Util, which allows us to bypass Perl coercion and manipulate the string and numeric components of a value separately. 

filter_none

edit
close

play_arrow

link
brightness_4
code

use Scalar::Util qw(blessed dualvar set_prototype);
$foo = dualvar 10, "Geeksfor";
$num = $foo + 2;                   
$str = $foo . " Geeks";             
print "$num\n";
print $str;

chevron_right


Output:

12
Geeksfor Geeks



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :
Practice Tags :


6


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.