X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/89a3b501a522bb324a76c9305f667dc2f0b4a8e1..76ed45178844dff782880573017d9b7c9fbc0007:/pod/perlsyn.pod diff --git a/pod/perlsyn.pod b/pod/perlsyn.pod index 9cceac0..80eca0a 100644 --- a/pod/perlsyn.pod +++ b/pod/perlsyn.pod @@ -68,7 +68,7 @@ subroutine without defining it by saying C, thus: X sub myname; - $me = myname $0 or die "can't get myname"; + $me = myname $0 or die "can't get myname"; A bare declaration like that declares the function to be a list operator, not a unary operator, so you have to be careful to use parentheses (or @@ -84,7 +84,7 @@ operator: That now parses as you'd expect, but you still ought to get in the habit of using parentheses in that situation. For more on prototypes, see -L +L. Subroutines declarations can also be loaded up with the C statement or both loaded and imported into your namespace with a C statement. @@ -116,16 +116,6 @@ C that I like compound statements, but aren't--they're just TERMs in an expression--and thus need an explicit termination when used as the last item in a statement. -=head2 Truth and Falsehood -X X X X X X X X<0> - -The number 0, the strings C<'0'> and C<"">, the empty list C<()>, and -C are all false in a boolean context. All other values are true. -Negation of a true value by C or C returns a special false value. -When evaluated as a string it is treated as C<"">, but as a number, it -is treated as 0. Most Perl operators -that return true or false behave this way. - =head2 Statement Modifiers X X X X X X X X X @@ -174,30 +164,42 @@ evaluated. This is so that you can write loops like: do { - $line = ; - ... + $line = ; + ... } until !defined($line) || $line eq ".\n" See L. Note also that the loop control statements described later will I work in this construct, because modifiers don't take loop labels. Sorry. You can always put another block inside of it -(for C) or around it (for C) to do that sort of thing. -For C, just double the braces: +(for C/C) or around it (for C) to do that sort of thing. X X X +For C or C, just double the braces: + do {{ - next if $x == $y; - # do something here + next if $x == $y; + # do something here }} until $x++ > $z; -For C, you have to be more elaborate: +For C, you have to be more elaborate and put braces around it: X - LOOP: { - do { - last if $x = $y**2; - # do something here - } while $x++ <= $z; + { + do { + last if $x == $y**2; + # do something here + } while $x++ <= $z; + } + +If you need both C and C, you have to do both and also use a +loop label: + + LOOP: { + do {{ + next if $x == $y; + last LOOP if $x == $y**2; + # do something here + }} until $x++ > $z; } B The behaviour of a C, C, or @@ -219,8 +221,8 @@ a C from inside a C and C from inside a C. Under the current implementation, the C loop can be anywhere within the C modifier's dynamic scope, but must be -within the C block's lexical scope. This restricted may -be relaxed in a future release. See L<"Switch Statements"> below. +within the C block's lexical scope. This restriction may +be relaxed in a future release. See L below. =head2 Compound Statements X X X X X @@ -267,7 +269,7 @@ The following compound statements may be used to control flow: PHASE BLOCK -The experimental C statement is I; see +The experimental C statement is I; see L below for how to do so, and the attendant caveats. Unlike in C and Pascal, in Perl these are all defined in terms of BLOCKs, @@ -280,7 +282,7 @@ all do the same thing: die "Can't open $FOO: $!" unless open(FOO); open(FOO) || die "Can't open $FOO: $!"; open(FOO) ? () : die "Can't open $FOO: $!"; - # a bit exotic, that last one + # a bit exotic, that last one The C statement is straightforward. Because BLOCKs are always bounded by curly brackets, there is never any ambiguity about which @@ -292,7 +294,7 @@ language construct, as everyone reading your code will have to think at least twice before they can understand what's going on. The C statement executes the block as long as the expression is -L. +true. The C statement executes the block as long as the expression is false. The LABEL is optional, and if present, consists of an identifier followed @@ -327,16 +329,16 @@ X X X X X X The C command starts the next iteration of the loop: LINE: while () { - next LINE if /^#/; # discard comments - ... + next LINE if /^#/; # discard comments + ... } The C command immediately exits the loop in question. The C block, if any, is not executed: LINE: while () { - last LINE if /^$/; # exit when done with header - ... + last LINE if /^$/; # exit when done with header + ... } The C command restarts the loop block without evaluating the @@ -349,23 +351,23 @@ If your input lines might end in backslashes to indicate continuation, you want to skip ahead and get the next record. while (<>) { - chomp; - if (s/\\$//) { - $_ .= <>; - redo unless eof(); - } - # now process $_ + chomp; + if (s/\\$//) { + $_ .= <>; + redo unless eof(); + } + # now process $_ } which is Perl shorthand for the more explicitly written version: LINE: while (defined($line = )) { - chomp($line); - if ($line =~ s/\\$//) { - $line .= ; - redo LINE unless eof(); # not eof(ARGV)! - } - # now process $line + chomp($line); + if ($line =~ s/\\$//) { + $line .= ; + redo LINE unless eof(); # not eof(ARGV)! + } + # now process $line } Note that if there were a C block on the above code, it would @@ -375,13 +377,13 @@ or C one-time matches: # inspired by :1,$g/fred/s//WILMA/ while (<>) { - m?(fred)? && s//WILMA $1 WILMA/; - m?(barney)? && s//BETTY $1 BETTY/; - m?(homer)? && s//MARGE $1 MARGE/; + m?(fred)? && s//WILMA $1 WILMA/; + m?(barney)? && s//BETTY $1 BETTY/; + m?(homer)? && s//MARGE $1 MARGE/; } continue { - print "$ARGV $.: $_"; - close ARGV if eof; # reset $. - reset if eof; # reset ?pat? + print "$ARGV $.: $_"; + close ARGV if eof; # reset $. + reset if eof; # reset ?pat? } If the word C is replaced by the word C, the sense of the @@ -392,14 +394,14 @@ Loop control statements don't work in an C or C, since they aren't loops. You can double the braces to make them such, though. if (/pattern/) {{ - last if /fred/; - next if /barney/; # same effect as "last", - # but doesn't document as well - # do something here + last if /fred/; + next if /barney/; # same effect as "last", + # but doesn't document as well + # do something here }} This is caused by the fact that a block by itself acts as a loop that -executes once, see L<"Basic BLOCKs">. +executes once, see L. The form C, available in Perl 4, is no longer available. Replace any occurrence of C by C. @@ -411,16 +413,16 @@ Perl's C-style C loop works like the corresponding C loop; that means that this: for ($i = 1; $i < 10; $i++) { - ... + ... } is the same as this: $i = 1; while ($i < 10) { - ... + ... } continue { - $i++; + $i++; } There is one minor difference: if variables are declared with C @@ -429,6 +431,21 @@ those variables is exactly the C loop (the body of the loop and the control sections). X +As a special case, if the test in the C loop (or the corresponding +C loop) is empty, it is treated as true. That is, both + + for (;;) { + ... + } + +and + + while () { + ... + } + +are treated as infinite loops. + Besides the normal array index looping, C can lend itself to many other interesting applications. Here's one that avoids the problem you get into if you explicitly test for end-of-file on @@ -439,7 +456,7 @@ X X X $on_a_tty = -t STDIN && -t STDOUT; sub prompt { print "yes? " if $on_a_tty } for ( prompt(); ; prompt() ) { - # do something + # do something } Using C (or the operator form, C<< >>) as the @@ -454,7 +471,7 @@ X X<< <> >> =head2 Foreach Loops X X -The C loop iterates over a normal list value and sets the +The C loop iterates over a normal list value and sets the scalar variable VAR to be each element of the list in turn. If the variable is preceded with the keyword C, then it is lexically scoped, and is therefore visible only within the loop. Otherwise, the variable is @@ -484,35 +501,50 @@ X C probably won't do what you expect if VAR is a tied or other special variable. Don't do that either. +As of Perl 5.22, there is an experimental variant of this loop that accepts +a variable preceded by a backslash for VAR, in which case the items in the +LIST must be references. The backslashed variable will become an alias +to each referenced item in the LIST, which must be of the correct type. +The variable needn't be a scalar in this case, and the backslash may be +followed by C. To use this form, you must enable the C +feature via C. (See L. See also L.) + Examples: for (@ary) { s/foo/bar/ } for my $elem (@elements) { - $elem *= 2; + $elem *= 2; } for $count (reverse(1..10), "BOOM") { - print $count, "\n"; - sleep(1); + print $count, "\n"; + sleep(1); } for (1..15) { print "Merry Christmas\n"; } foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) { - print "Item: $item\n"; + print "Item: $item\n"; + } + + use feature "refaliasing"; + no warnings "experimental::refaliasing"; + foreach \my %hash (@array_of_hash_references) { + # do something which each %hash } Here's how a C programmer might code up a particular algorithm in Perl: for (my $i = 0; $i < @ary1; $i++) { - for (my $j = 0; $j < @ary2; $j++) { - if ($ary1[$i] > $ary2[$j]) { - last; # can't go to outer :-( - } - $ary1[$i] += $ary2[$j]; - } - # this is where that last takes me + for (my $j = 0; $j < @ary2; $j++) { + if ($ary1[$i] > $ary2[$j]) { + last; # can't go to outer :-( + } + $ary1[$i] += $ary2[$j]; + } + # this is where that last takes me } Whereas here's how a Perl programmer more comfortable with the idiom might @@ -520,10 +552,10 @@ do it: OUTER: for my $wid (@ary1) { INNER: for my $jet (@ary2) { - next OUTER if $wid > $jet; - $wid += $jet; - } - } + next OUTER if $wid > $jet; + $wid += $jet; + } + } See how much easier this is? It's cleaner, safer, and faster. It's cleaner because it's less noisy. It's safer because if code gets added @@ -533,6 +565,12 @@ rather than merely terminating the inner one. And it's faster because Perl executes a C statement more rapidly than it would the equivalent C loop. +Perceptive Perl hackers may have noticed that a C loop has a return +value, and that this value can be captured by wrapping the loop in a C +block. The reward for this discovery is this cautionary advice: The +return value of a C loop is unspecified and may change without notice. +Do not rely on it. + =head2 Basic BLOCKs X @@ -546,10 +584,10 @@ block is optional. The BLOCK construct can be used to emulate case structures. SWITCH: { - if (/^abc/) { $abc = 1; last SWITCH; } - if (/^def/) { $def = 1; last SWITCH; } - if (/^xyz/) { $xyz = 1; last SWITCH; } - $nothing = 1; + if (/^abc/) { $abc = 1; last SWITCH; } + if (/^def/) { $def = 1; last SWITCH; } + if (/^xyz/) { $xyz = 1; last SWITCH; } + $nothing = 1; } You'll also find that C loop used to create a topicalizer @@ -557,10 +595,10 @@ and a switch: SWITCH: for ($var) { - if (/^abc/) { $abc = 1; last SWITCH; } - if (/^def/) { $def = 1; last SWITCH; } - if (/^xyz/) { $xyz = 1; last SWITCH; } - $nothing = 1; + if (/^abc/) { $abc = 1; last SWITCH; } + if (/^def/) { $def = 1; last SWITCH; } + if (/^xyz/) { $xyz = 1; last SWITCH; } + $nothing = 1; } Such constructs are quite frequently used, both because older versions of @@ -590,15 +628,15 @@ Starting from Perl 5.16, one can prefix the switch keywords with C to access the feature without a C statement. The keywords C and C are analogous to C and -C in other languages, so the code in the previous section could be -rewritten as +C in other languages -- though C is not -- so the code +in the previous section could be rewritten as use v5.10.1; for ($var) { - when (/^abc/) { $abc = 1 } - when (/^def/) { $def = 1 } - when (/^xyz/) { $xyz = 1 } - default { $nothing = 1 } + when (/^abc/) { $abc = 1 } + when (/^def/) { $def = 1 } + when (/^xyz/) { $xyz = 1 } + default { $nothing = 1 } } The C is the non-experimental way to set a topicalizer. @@ -607,55 +645,54 @@ written like this: use v5.10.1; given ($var) { - when (/^abc/) { $abc = 1 } - when (/^def/) { $def = 1 } - when (/^xyz/) { $xyz = 1 } - default { $nothing = 1 } + when (/^abc/) { $abc = 1 } + when (/^def/) { $def = 1 } + when (/^xyz/) { $xyz = 1 } + default { $nothing = 1 } } As of 5.14, that can also be written this way: use v5.14; for ($var) { - $abc = 1 when /^abc/; - $def = 1 when /^def/; - $xyz = 1 when /^xyz/; - default { $nothing = 1 } + $abc = 1 when /^abc/; + $def = 1 when /^def/; + $xyz = 1 when /^xyz/; + default { $nothing = 1 } } Or if you don't care to play it safe, like this: use v5.14; given ($var) { - $abc = 1 when /^abc/; - $def = 1 when /^def/; - $xyz = 1 when /^xyz/; - default { $nothing = 1 } + $abc = 1 when /^abc/; + $def = 1 when /^def/; + $xyz = 1 when /^xyz/; + default { $nothing = 1 } } The arguments to C and C are in scalar context, -and C assigns the C<$_> variable its topic value. +and C aliases the C<$_> variable to the result of evaluating its +topic expression. Exactly what the I argument to C does is hard to describe precisely, but in general, it tries to guess what you want done. Sometimes -it is interpreted as C<< $_ ~~ I >>, and sometimes it does not. It +it is interpreted as C<< $_ ~~ I >>, and sometimes it is not. It also behaves differently when lexically enclosed by a C block than it does when dynamically enclosed by a C loop. The rules are far too difficult to understand to be described here. See L later on. Due to an unfortunate bug in how C was implemented between Perl 5.10 -and 5.14, under those implementations the version of C<$_> governed by +and 5.16, under those implementations the version of C<$_> governed by C is merely a lexically scoped copy of the original, not a dynamically scoped alias to the original, as it would be if it were a C or under both the original and the current Perl 6 language -specification. This bug is expected to be addressed in a future release of -Perl. For forwards compatibility, if you really want a lexical C<$_>, -specify that explicitly: +specification. This bug was fixed in Perl 5.18 (and lexicalized C<$_> itself +was removed in Perl 5.24). - given(my $_ = EXPR) { ... } - -In the meanwhile, stick to C for your topicalizer and +If your code still needs to run on older versions, +stick to C for your topicalizer and you will be less unhappy. =head2 Goto @@ -708,13 +745,8 @@ X X Beginning in Perl 5.12, Perl accepts an ellipsis, "C<...>", as a -placeholder for code that you haven't implemented yet. This form of -ellipsis, the unimplemented statement, should not be confused with the -binary flip-flop C<...> operator. One is a statement and the other an -operator. (Perl doesn't usually confuse them because usually Perl can tell -whether it wants an operator or a statement, but see below for exceptions.) - -When Perl 5.12 or later encounters an ellipses statement, it parses this +placeholder for code that you haven't implemented yet. +When Perl 5.12 or later encounters an ellipsis statement, it parses this without error, but if and when you should actually try to execute it, Perl throws an exception with the text C: @@ -722,11 +754,14 @@ throws an exception with the text C: sub unimplemented { ... } eval { unimplemented() }; if ($@ =~ /^Unimplemented at /) { - say "I found an ellipsis!"; + say "I found an ellipsis!"; } -You can only use the elliptical statement to stand in for a -complete statement. These examples of how the ellipsis works: +You can only use the elliptical statement to stand in for a complete +statement. Syntactically, "C<...;>" is a complete statement, but, +as with other kinds of semicolon-terminated statement, the semicolon +may be omitted if "C<...>" appears immediately before a closing brace. +These examples show how the ellipsis works: use v5.12; { ... } @@ -734,20 +769,18 @@ complete statement. These examples of how the ellipsis works: ...; eval { ... }; sub somemeth { - my $self = shift; - ...; + my $self = shift; + ...; } $x = do { - my $n; - ...; - say "Hurrah!"; - $n; + my $n; + ...; + say "Hurrah!"; + $n; }; The elliptical statement cannot stand in for an expression that -is part of a larger statement, since the C<...> is also the three-dot -version of the flip-flop operator (see L). - +is part of a larger statement. These examples of attempts to use an ellipsis are syntax errors: use v5.12; @@ -755,29 +788,21 @@ These examples of attempts to use an ellipsis are syntax errors: print ...; open(my $fh, ">", "/dev/passwd") or ...; if ($condition && ... ) { say "Howdy" }; + ... if $a > $b; + say "Cromulent" if ...; + $flub = 5 + ...; There are some cases where Perl can't immediately tell the difference between an expression and a statement. For instance, the syntax for a block and an anonymous hash reference constructor look the same unless there's something in the braces to give Perl a hint. The ellipsis is a -syntax error if Perl doesn't guess that the C<{ ... }> is a block. In that -case, it doesn't think the C<...> is an ellipsis because it's expecting an -expression instead of a statement: - - @transformed = map { ... } @input; # syntax error - -You can use a C<;> inside your block to denote that the C<{ ... }> is a -block and not a hash reference constructor. Now the ellipsis works: - - @transformed = map {; ... } @input; # ; disambiguates - - @transformed = map { ...; } @input; # ; disambiguates +syntax error if Perl doesn't guess that the C<{ ... }> is a block. +Inside your block, you can use a C<;> before the ellipsis to denote that the +C<{ ... }> is a block and not a hash reference constructor. Note: Some folks colloquially refer to this bit of punctuation as a "yada-yada" or "triple-dot", but its true name -is actually an ellipsis. Perl does not yet -accept the Unicode version, U+2026 HORIZONTAL ELLIPSIS, as an alias for -C<...>, but someday it may. +is actually an ellipsis. =head2 PODs: Embedded Documentation X X @@ -804,8 +829,8 @@ and your documentation text freely, as in =cut back to the compiler, nuff of this pod stuff! sub snazzle($) { - my $thingie = shift; - ......... + my $thingie = shift; + ......... } Note that pod translators should look at only paragraphs beginning @@ -883,47 +908,52 @@ shell: As previously mentioned, the "switch" feature is considered highly experimental; it is subject to change with little notice. In particular, -both C and C have tricky behaviours that are expected to -change to become less tricky in the future. Do not rely upon their -current (mis)implementations. +C has tricky behaviours that are expected to change to become less +tricky in the future. Do not rely upon its current (mis)implementation. +Before Perl 5.28, C also had tricky behaviours that you should still +beware of if your code must run on older versions of Perl. Here is a longer example of C: use feature ":5.10"; given ($foo) { - when (undef) { - say '$foo is undefined'; - } - when ("foo") { - say '$foo is the string "foo"'; - } - when ([1,3,5,7,9]) { - say '$foo is an odd digit'; - continue; # Fall through - } - when ($_ < 100) { - say '$foo is numerically less than 100'; - } - when (\&complicated_check) { - say 'a complicated check for $foo is true'; - } - default { - die q(I don't know what to do with $foo); - } + when (undef) { + say '$foo is undefined'; + } + when ("foo") { + say '$foo is the string "foo"'; + } + when ([1,3,5,7,9]) { + say '$foo is an odd digit'; + continue; # Fall through + } + when ($_ < 100) { + say '$foo is numerically less than 100'; + } + when (\&complicated_check) { + say 'a complicated check for $foo is true'; + } + default { + die q(I don't know what to do with $foo); + } } -As currently implemented, C assign the value of I to +Before Perl 5.18, C assigned the value of I to merely a lexically scoped I> (!) of C<$_>, not a dynamically -scoped alias the way C does. That makes it similar to +scoped alias the way C does. That made it similar to - do { my $_ = EXPR; ... } + do { my $_ = EXPR; ... } -except that the block is automatically broken out of by a -successful C or an explicit C. Because it is only a -copy, and because it is only lexically scoped, not dynamically -scoped, you cannot do the things with it that you are used to in -a C loop. In particular, you probably cannot use -arbitrary function calls. Best stick to C for that. +except that the block was automatically broken out of by a successful +C or an explicit C. Because it was only a copy, and because +it was only lexically scoped, not dynamically scoped, you could not do the +things with it that you are used to in a C loop. In particular, +it did not work for arbitrary function calls if those functions might try +to access $_. Best stick to C for that. + +Before Perl 5.28, if the I in C was an array or hash +reference then the topic would be a reference to that array or hash, +rather than the result of evaluating the array or hash in scalar context. Most of the power comes from the implicit smartmatching that can sometimes apply. Most of the time, C is treated as an @@ -934,49 +964,48 @@ listed below, it is used directly as a boolean. =over 4 -=item 1. +=item Z<>1. A user-defined subroutine call or a method invocation. -=item 2. +=item Z<>2. A regular expression match in the form of C, C<$foo =~ /REGEX/>, or C<$foo =~ EXPR>. Also, a negated regular expression match in the form C, C<$foo !~ /REGEX/>, or C<$foo !~ EXPR>. -=item 3. +=item Z<>3. A smart match that uses an explicit C<~~> operator, such as C. -=item 4. +B You will often have to use C<$c ~~ $_> because the default case +uses C<$_ ~~ $c> , which is frequentlythe opposite of what you want. + +=item Z<>4. -A boolean comparison operator such as C<$_ E 10> or C<$x eq "abc"> The +A boolean comparison operator such as C<$_ E 10> or C<$x eq "abc">. The relational operators that this applies to are the six numeric comparisons (C<< < >>, C<< > >>, C<< <= >>, C<< >= >>, C<< == >>, and C<< != >>), and the six string comparisons (C, C, C, C, C, and C). -B You will often have to use C<$c ~~ $_> because -the default case uses C<$_ ~~ $c> , which is frequently -the opposite of what you want. - -=item 5. +=item Z<>5. At least the three builtin functions C, C, and C. We might someday add more of these later if we think of them. -=item 6. +=item Z<>6. A negated expression, whether C or C, or a logical exclusive-or, C<(EXPR1) xor (EXPR2)>. The bitwise versions (C<~> and C<^>) are not included. -=item 7. +=item Z<>7. A filetest operator, with exactly 4 exceptions: C<-s>, C<-M>, C<-A>, and C<-C>, as these return numerical values, not boolean ones. The C<-z> filetest operator is not included in the exception list. -=item 8. +=item Z<>8. The C<..> and C<...> flip-flop operators. Note that the C<...> flip-flop operator is completely different from the C<...> elliptical statement @@ -993,7 +1022,7 @@ above test to the operands: =over 4 -=item 9. +=item Z<>9. If EXPR is C or C, the test is applied I to both EXPR1 and EXPR2. @@ -1001,7 +1030,7 @@ Only if I operands also pass the test, I, will the expression be treated as boolean. Otherwise, smartmatching is used. -=item 10. +=item Z<>10. If EXPR is C, C, or C, the test is applied I to EXPR1 only (which might itself be a @@ -1075,12 +1104,12 @@ a C. =head3 Fall-through You can use the C keyword to fall through from one -case to the next: +case to the next immediate C or C: given($foo) { - when (/x/) { say '$foo contains an x'; continue } - when (/y/) { say '$foo contains a y' } - default { say '$foo does not contain a y' } + when (/x/) { say '$foo contains an x'; continue } + when (/y/) { say '$foo contains a y' } + default { say '$foo does not contain a y' } } =head3 Return value @@ -1113,12 +1142,12 @@ Note that, unlike C and C, failed C statements always evaluate to an empty list. my $price = do { - given ($item) { - when (["pear", "apple"]) { 1 } - break when "vote"; # My vote cannot be bought - 1e10 when /Mona Lisa/; - "unknown"; - } + given ($item) { + when (["pear", "apple"]) { 1 } + break when "vote"; # My vote cannot be bought + 1e10 when /Mona Lisa/; + "unknown"; + } }; Currently, C blocks can't always @@ -1134,7 +1163,7 @@ string occurs in an array: use v5.10.1; my $count = 0; for (@array) { - when ("foo") { ++$count } + when ("foo") { ++$count } } print "\@array contains $count copies of 'foo'\n"; @@ -1143,7 +1172,7 @@ Or in a more recent version: use v5.14; my $count = 0; for (@array) { - ++$count when "foo"; + ++$count when "foo"; } print "\@array contains $count copies of 'foo'\n"; @@ -1166,7 +1195,7 @@ made optional in Perl 5 without a great deal of potential confusion, because Perl 5 would parse the expression given $foo { - ... + ... } as though the argument to C were an element of the hash @@ -1189,7 +1218,7 @@ this works in Perl 5: say "that's all, folks!"; But it doesn't work at all in Perl 6. Instead, you should -use the (parallelizable) C operator instead: +use the (parallelizable) C operator: if any(@primary) eq "red" { say "primary smartmatches red"; @@ -1205,7 +1234,7 @@ differences between Perl 6's and Perl 5's data models, but also because the Perl 6 spec has changed since Perl 5 rushed into early adoption. In Perl 6, C will always do an implicit smartmatch with its -argument, while in Perl 5 it is convenient albeit potentially confusing) to +argument, while in Perl 5 it is convenient (albeit potentially confusing) to suppress this implicit smartmatch in various rather loosely-defined situations, as roughly outlined above. (The difference is largely because Perl 5 does not have, even internally, a boolean type.)