Yes, I guess it is explicit in Perl. In terms of language design, the interesting question is whether the Python/Ruby demand to explicitly cast/coerce by calling int is "stronger/safer typing" or "ugly explicit casting" (frowned upon in C++, for example). Let's clarify with a little test program.

In Perl, running:

use strict;
use warnings;
my $x = "2abc";
my $y = $x + 42;
print "x=", $x, " y=", $y, "\n";
[download]

Argument "2abc" isn't numeric in addition (+) at f.pl line 4.
x=2abc y=44
[download]

In Python, running:

x = "2abc"
y = x + 42
print "x=", x, "y=", y, "\n"
[download]

Traceback (most recent call last):
  File "f.py", line 2, in <module>
    y = x + 42
TypeError: cannot concatenate 'str' and 'int' objects
[download]

while running:

x = "2abc"
y = int(x) + 42
print "x=", x, "y=", y, "\n"
[download]

Traceback (most recent call last):
  File "f2.py", line 2, in <module>
    y = int(x) + 42
ValueError: invalid literal for int() with base 10: '2abc'
[download]

x = "2abc"
y = int(x[0:1]) + 42
print "x=", x, "y=", y, "\n"
[download]

x= 2abc y= 44
[download]

In Ruby, running:

x = "2abc"
y = x + 42
print "x=", x, "y=", y, "\n"
[download]

f.rb:2:in `+': can't convert Fixnum into String (TypeError)
    from f.rb:2
[download]

x = "2abc"
y = x.to_i() + 42
print "x=", x, " y=", y, "\n"
[download]

x=2abc y=44
[download]

I guess Ruby and Python need to do it that way because the + operator is overloaded for both numeric addition and string concatenation, while Perl has a separate string concatenation operator, and so there is no ambiguity.

Update: Python's stricter typing can produce other subtle differences. For example, in Python both 5 * "X" and "X" * 5 produce five Xs. Not so in Perl or Ruby. That is, the string multiply operator is commutative in Python, but not in Perl or Ruby. Not sure if string multiply commutativity is a bug or a feature. Curiously, the new Perl 5.10 smart match operator ~~ was commutative in Perl 5.10.0, then that was deemed a mistake and it was made non-commutative in Perl 5.10.1.

> I guess Ruby and Python need to do it that way because the + operator is overloaded for both numeric addition and string concatenation, while Perl has a separate string concatenation operator, and so there is no ambiguity.

exactly, look at JS to see the mess happening, when you have implicit convertions combined with only one operator for addition AND concatenation.

BTW: Ruby's .to_i and .to_f are closer to Perl than JS parseInt() and parseFloat(). Trying to convert a non-numeric string like "abc" in Perl and Ruby produces 0 but in JS it's NaN (not-a-number) a value which doesn't produce a warning!

perl -we' print 4+"abc"'
Argument "abc" isn't numeric in addition (+) at -e line 1.
4
[download]

Cheers Rolf