perltrap: #109408

1 files changed, 0 insertions, 1239 deletions

diff --git a/pod/perltrap.pod b/pod/perltrap.pod
index e4fbb23a53..ee17470266 100644
--- a/pod/perltrap.pod
+++ b/pod/perltrap.pod
@@ -347,1245 +347,6 @@ external name is still an alias for the original.
 
 =back
 
-=head2 Perl4 to Perl5 Traps
-
-Practicing Perl4 Programmers should take note of the following
-Perl4-to-Perl5 specific traps.
-
-They're crudely ordered according to the following list:
-
-=over 4
-
-=item Discontinuance, Deprecation, and BugFix traps
-
-Anything that's been fixed as a perl4 bug, removed as a perl4 feature
-or deprecated as a perl4 feature with the intent to encourage usage of
-some other perl5 feature.
-
-=item Parsing Traps
-
-Traps that appear to stem from the new parser.
-
-=item Numerical Traps
-
-Traps having to do with numerical or mathematical operators.
-
-=item General data type traps
-
-Traps involving perl standard data types.
-
-=item Context Traps - scalar, list contexts
-
-Traps related to context within lists, scalar statements/declarations.
-
-=item Precedence Traps
-
-Traps related to the precedence of parsing, evaluation, and execution of
-code.
-
-=item General Regular Expression Traps using s///, etc.
-
-Traps related to the use of pattern matching.
-
-=item Subroutine, Signal, Sorting Traps
-
-Traps related to the use of signals and signal handlers, general subroutines,
-and sorting, along with sorting subroutines.
-
-=item OS Traps
-
-OS-specific traps.
-
-=item DBM Traps
-
-Traps specific to the use of C<dbmopen()>, and specific dbm implementations.
-
-=item Unclassified Traps
-
-Everything else.
-
-=back
-
-If you find an example of a conversion trap that is not listed here,
-please submit it to <F<perlbug@perl.org>> for inclusion.
-Also note that at least some of these can be caught with the
-C<use warnings> pragma or the B<-w> switch.
-
-=head2 Discontinuance, Deprecation, and BugFix traps
-
-Anything that has been discontinued, deprecated, or fixed as
-a bug from perl4.
-
-=over 4
-
-=item * Symbols starting with "_" no longer forced into main
-
-Symbols starting with "_" are no longer forced into package main, except
-for C<$_> itself (and C<@_>, etc.).
-
-    package test;
-    $_legacy = 1;
-
-    package main;
-    print "\$_legacy is ",$_legacy,"\n";
-
-    # perl4 prints: $_legacy is 1
-    # perl5 prints: $_legacy is
-
-=item * Double-colon valid package separator in variable name
-
-Double-colon is now a valid package separator in a variable name.  Thus these
-behave differently in perl4 vs. perl5, because the packages don't exist.
-
-    $a=1;$b=2;$c=3;$var=4;
-    print "$a::$b::$c ";
-    print "$var::abc::xyz\n";
-
-    # perl4 prints: 1::2::3 4::abc::xyz
-    # perl5 prints: 3
-
-Given that C<::> is now the preferred package delimiter, it is debatable
-whether this should be classed as a bug or not.
-(The older package delimiter, ' ,is used here)
-
-    $x = 10;
-    print "x=${'x}\n";
-
-    # perl4 prints: x=10
-    # perl5 prints: Can't find string terminator "'" anywhere before EOF
-
-You can avoid this problem, and remain compatible with perl4, if you
-always explicitly include the package name:
-
-    $x = 10;
-    print "x=${main'x}\n";
-
-Also see precedence traps, for parsing C<$:>.
-
-=item * 2nd and 3rd args to C<splice()> are now in scalar context
-
-The second and third arguments of C<splice()> are now evaluated in scalar
-context (as the Camel says) rather than list context.
-
-    sub sub1{return(0,2) }          # return a 2-element list
-    sub sub2{ return(1,2,3)}        # return a 3-element list
-    @a1 = ("a","b","c","d","e");
-    @a2 = splice(@a1,&sub1,&sub2);
-    print join(' ',@a2),"\n";
-
-    # perl4 prints: a b
-    # perl5 prints: c d e
-
-=item * Can't do C<goto> into a block that is optimized away
-
-You can't do a C<goto> into a block that is optimized away.  Darn.
-
-    goto marker1;
-
-    for(1){
-    marker1:
-        print "Here I is!\n";
-    }
-
-    # perl4 prints: Here I is!
-    # perl5 errors: Can't "goto" into the middle of a foreach loop
-
-=item * Can't use whitespace as variable name or quote delimiter
-
-It is no longer syntactically legal to use whitespace as the name
-of a variable, or as a delimiter for any kind of quote construct.
-Double darn.
-
-    $a = ("foo bar");
-    $b = q baz ;
-    print "a is $a, b is $b\n";
-
-    # perl4 prints: a is foo bar, b is baz
-    # perl5 errors: Bareword found where operator expected
-
-=item * C<while/if BLOCK BLOCK> gone
-
-The archaic while/if BLOCK BLOCK syntax is no longer supported.
-
-    if { 1 } {
-        print "True!";
-    }
-    else {
-        print "False!";
-    }
-
-    # perl4 prints: True!
-    # perl5 errors: syntax error at test.pl line 1, near "if {"
-
-=item * C<**> binds tighter than unary minus
-
-The C<**> operator now binds more tightly than unary minus.
-It was documented to work this way before, but didn't.
-
-    print -4**2,"\n";
-
-    # perl4 prints: 16
-    # perl5 prints: -16
-
-=item * C<foreach> changed when iterating over a list
-
-The meaning of C<foreach{}> has changed slightly when it is iterating over a
-list which is not an array.  This used to assign the list to a
-temporary array, but no longer does so (for efficiency).  This means
-that you'll now be iterating over the actual values, not over copies of
-the values.  Modifications to the loop variable can change the original
-values.
-
-    @list = ('ab','abc','bcd','def');
-    foreach $var (grep(/ab/,@list)){
-        $var = 1;
-    }
-    print (join(':',@list));
-
-    # perl4 prints: ab:abc:bcd:def
-    # perl5 prints: 1:1:bcd:def
-
-To retain Perl4 semantics you need to assign your list
-explicitly to a temporary array and then iterate over that.  For
-example, you might need to change
-
-    foreach $var (grep(/ab/,@list)){
-
-to
-
-    foreach $var (@tmp = grep(/ab/,@list)){
-
-Otherwise changing $var will clobber the values of @list.  (This most often
-happens when you use C<$_> for the loop variable, and call subroutines in
-the loop that don't properly localize C<$_>.)
-
-=item * C<split> with no args behavior changed
-
-C<split> with no arguments now behaves like C<split ' '> (which doesn't
-return an initial null field if $_ starts with whitespace), it used to
-behave like C<split /\s+/> (which does).
-
-    $_ = ' hi mom';
-    print join(':', split);
-
-    # perl4 prints: :hi:mom
-    # perl5 prints: hi:mom
-
-=item * B<-e> behavior fixed
-
-Perl 4 would ignore any text which was attached to an B<-e> switch,
-always taking the code snippet from the following arg.  Additionally, it
-would silently accept an B<-e> switch without a following arg.  Both of
-these behaviors have been fixed.
-
-    perl -e'print "attached to -e"' 'print "separate arg"'
-
-    # perl4 prints: separate arg
-    # perl5 prints: attached to -e
-
-    perl -e
-
-    # perl4 prints:
-    # perl5 dies: No code specified for -e.
-
-=item * C<push> returns number of elements in resulting list
-
-In Perl 4 the return value of C<push> was undocumented, but it was
-actually the last value being pushed onto the target list.  In Perl 5
-the return value of C<push> is documented, but has changed, it is the
-number of elements in the resulting list.
-
-    @x = ('existing');
-    print push(@x, 'first new', 'second new');
-
-    # perl4 prints: second new
-    # perl5 prints: 3
-
-=item * Some error messages differ
-
-Some error messages will be different.
-
-=item * C<split()> honors subroutine args
-
-In Perl 4, if in list context the delimiters to the first argument of
-C<split()> were C<??>, the result would be placed in C<@_> as well as
-being returned.   Perl 5 has more respect for your subroutine arguments.
-
-=item * Bugs removed
-
-Some bugs may have been inadvertently removed.  :-)
-
-=back
-
-=head2 Parsing Traps
-
-Perl4-to-Perl5 traps from having to do with parsing.
-
-=over 4
-
-=item * Space between . and = triggers syntax error
-
-Note the space between . and =
-
-    $string . = "more string";
-    print $string;
-
-    # perl4 prints: more string
-    # perl5 prints: syntax error at - line 1, near ". ="
-
-=item * Better parsing in perl 5
-
-Better parsing in perl 5
-
-    sub foo {}
-    &foo
-    print("hello, world\n");
-
-    # perl4 prints: hello, world
-    # perl5 prints: syntax error
-
-=item * Function parsing
-
-"if it looks like a function, it is a function" rule.
-
-  print
-    ($foo == 1) ? "is one\n" : "is zero\n";
-
-    # perl4 prints: is zero
-    # perl5 warns: "Useless use of a constant in void context" if using -w
-
-=item * String interpolation of C<$#array> differs
-
-String interpolation of the C<$#array> construct differs when braces
-are to used around the name.
-
-    @a = (1..3);
-    print "${#a}";
-
-    # perl4 prints: 2
-    # perl5 fails with syntax error
-
-    @a = (1..3);
-    print "$#{a}";
-
-    # perl4 prints: {a}
-    # perl5 prints: 2
-
-=item * Perl guesses on C<map>, C<grep> followed by C<{> if it starts BLOCK or hash ref
-
-When perl sees C<map {> (or C<grep {>), it has to guess whether the C<{>
-starts a BLOCK or a hash reference. If it guesses wrong, it will report
-a syntax error near the C<}> and the missing (or unexpected) comma.
-
-Use unary C<+> before C<{> on a hash reference, and unary C<+> applied
-to the first thing in a BLOCK (after C<{>), for perl to guess right all
-the time. (See L<perlfunc/map>.)
-
-=back
-
-=head2 Numerical Traps
-
-Perl4-to-Perl5 traps having to do with numerical operators,
-operands, or output from same.
-
-=over 5
-
-=item * Formatted output and significant digits
-
-Formatted output and significant digits.  In general, Perl 5
-tries to be more precise.  For example, on a Solaris Sparc:
-
-    print 7.373504 - 0, "\n";
-    printf "%20.18f\n", 7.373504 - 0;
-
-    # Perl4 prints:
-    7.3750399999999996141
-    7.375039999999999614
-
-    # Perl5 prints:
-    7.373504
-    7.373503999999999614
-
-Notice how the first result looks better in Perl 5.
-
-Your results may vary, since your floating point formatting routines
-and even floating point format may be slightly different.
-
-=item * Auto-increment operator over signed int limit deleted
-
-This specific item has been deleted.  It demonstrated how the auto-increment
-operator would not catch when a number went over the signed int limit.  Fixed
-in version 5.003_04.  But always be wary when using large integers.
-If in doubt:
-
-   use Math::BigInt;
-
-=item * Assignment of return values from numeric equality tests doesn't work
-
-Assignment of return values from numeric equality tests
-does not work in perl5 when the test evaluates to false (0).
-Logical tests now return a null, instead of 0
-
-    $p = ($test == 1);
-    print $p,"\n";
-
-    # perl4 prints: 0
-    # perl5 prints:
-
-Also see L<"General Regular Expression Traps using s///, etc.">
-for another example of this new feature...
-
-=item * Bitwise string ops
-
-When bitwise operators which can operate upon either numbers or
-strings (C<& | ^ ~>) are given only strings as arguments, perl4 would
-treat the operands as bitstrings so long as the program contained a call
-to the C<vec()> function. perl5 treats the string operands as bitstrings.
-(See L<perlop/Bitwise String Operators> for more details.)
-
-    $fred = "10";
-    $barney = "12";
-    $betty = $fred & $barney;
-    print "$betty\n";
-    # Uncomment the next line to change perl4's behavior
-    # ($dummy) = vec("dummy", 0, 0);
-
-    # Perl4 prints:
-    8
-
-    # Perl5 prints:
-    10
-
-    # If vec() is used anywhere in the program, both print:
-    10
-
-=back
-
-=head2 General data type traps
-
-Perl4-to-Perl5 traps involving most data-types, and their usage
-within certain expressions and/or context.
-
-=over 5
-
-=item * Negative array subscripts now count from the end of array
-
-Negative array subscripts now count from the end of the array.
-
-    @a = (1, 2, 3, 4, 5);
-    print "The third element of the array is $a[3] also expressed as $a[-2] \n";
-
-    # perl4 prints: The third element of the array is 4 also expressed as
-    # perl5 prints: The third element of the array is 4 also expressed as 4
-
-=item * Setting C<$#array> lower now discards array elements
-
-Setting C<$#array> lower now discards array elements, and makes them
-impossible to recover.
-
-    @a = (a,b,c,d,e);
-    print "Before: ",join('',@a);
-    $#a =1;
-    print ", After: ",join('',@a);
-    $#a =3;
-    print ", Recovered: ",join('',@a),"\n";
-
-    # perl4 prints: Before: abcde, After: ab, Recovered: abcd
-    # perl5 prints: Before: abcde, After: ab, Recovered: ab
-
-=item * Hashes get defined before use
-
-Hashes get defined before use
-
-    local($s,@a,%h);
-    die "scalar \$s defined" if defined($s);
-    die "array \@a defined" if defined(@a);
-    die "hash \%h defined" if defined(%h);
-
-    # perl4 prints:
-    # perl5 dies: hash %h defined
-
-Perl will now generate a warning when it sees defined(@a) and
-defined(%h).
-
-=item * Glob assignment from localized variable to variable
-
-glob assignment from variable to variable will fail if the assigned
-variable is localized subsequent to the assignment
-
-    @a = ("This is Perl 4");
-    *b = *a;
-    local(@a);
-    print @b,"\n";
-
-    # perl4 prints: This is Perl 4
-    # perl5 prints:
-
-=item * Assigning C<undef> to glob
-
-Assigning C<undef> to a glob has no effect in Perl 5.   In Perl 4
-it undefines the associated scalar (but may have other side effects
-including SEGVs). Perl 5 will also warn if C<undef> is assigned to a
-typeglob. (Note that assigning C<undef> to a typeglob is different
-than calling the C<undef> function on a typeglob (C<undef *foo>), which
-has quite a few effects.
-
-    $foo = "bar";
-    *foo = undef;
-    print $foo;
-
-    # perl4 prints:
-    # perl4 warns: "Use of uninitialized variable" if using -w
-    # perl5 prints: bar
-    # perl5 warns: "Undefined value assigned to typeglob" if using -w
-
-=item * Changes in unary negation (of strings)
-
-Changes in unary negation (of strings)
-This change effects both the return value and what it
-does to auto(magic)increment.
-
-    $x = "aaa";
-    print ++$x," : ";
-    print -$x," : ";
-    print ++$x,"\n";
-
-    # perl4 prints: aab : -0 : 1
-    # perl5 prints: aab : -aab : aac
-
-=item * Modifying of constants prohibited
-
-perl 4 lets you modify constants:
-
-    $foo = "x";
-    &mod($foo);
-    for ($x = 0; $x < 3; $x++) {
-        &mod("a");
-    }
-    sub mod {
-        print "before: $_[0]";
-        $_[0] = "m";
-        print "  after: $_[0]\n";
-    }
-
-    # perl4:
-    # before: x  after: m
-    # before: a  after: m
-    # before: m  after: m
-    # before: m  after: m
-
-    # Perl5:
-    # before: x  after: m
-    # Modification of a read-only value attempted at foo.pl line 12.
-    # before: a
-
-=item * C<defined $var> behavior changed
-
-The behavior is slightly different for:
-
-    print "$x", defined $x
-
-    # perl 4: 1
-    # perl 5: <no output, $x is not called into existence>
-
-=item * Variable Suicide
-
-Variable suicide behavior is more consistent under Perl 5.
-Perl5 exhibits the same behavior for hashes and scalars,
-that perl4 exhibits for only scalars.
-
-    $aGlobal{ "aKey" } = "global value";
-    print "MAIN:", $aGlobal{"aKey"}, "\n";
-    $GlobalLevel = 0;
-    &test( *aGlobal );
-
-    sub test {
-        local( *theArgument ) = @_;
-        local( %aNewLocal ); # perl 4 != 5.001l,m
-        $aNewLocal{"aKey"} = "this should never appear";
-        print "SUB: ", $theArgument{"aKey"}, "\n";
-        $aNewLocal{"aKey"} = "level $GlobalLevel";   # what should print
-        $GlobalLevel++;
-        if( $GlobalLevel<4 ) {
-            &test( *aNewLocal );
-        }
-    }
-
-    # Perl4:
-    # MAIN:global value
-    # SUB: global value
-    # SUB: level 0
-    # SUB: level 1
-    # SUB: level 2
-
-    # Perl5:
-    # MAIN:global value
-    # SUB: global value
-    # SUB: this should never appear
-    # SUB: this should never appear
-    # SUB: this should never appear
-
-=back
-
-=head2 Context Traps - scalar, list contexts
-
-=over 5
-
-=item * Elements of argument lists for formats evaluated in list context
-
-The elements of argument lists for formats are now evaluated in list
-context.  This means you can interpolate list values now.
-
-    @fmt = ("foo","bar","baz");
-    format STDOUT=
-    @<<<<< @||||| @>>>>>
-    @fmt;
-    .
-    write;
-
-    # perl4 errors:  Please use commas to separate fields in file
-    # perl5 prints: foo     bar      baz
-
-=item * C<caller()> returns false value in scalar context if no caller present
-
-The C<caller()> function now returns a false value in a scalar context
-if there is no caller.  This lets library files determine if they're
-being required.
-
-    caller() ? (print "You rang?\n") : (print "Got a 0\n");
-
-    # perl4 errors: There is no caller
-    # perl5 prints: Got a 0
-
-=item * Comma operator in scalar context gives scalar context to args
-
-The comma operator in a scalar context is now guaranteed to give a
-scalar context to its last argument. It gives scalar or void context
-to any preceding arguments, depending on circumstances.
-
-    @y= ('a','b','c');
-    $x = (1, 2, @y);
-    print "x = $x\n";
-
-    # Perl4 prints:  x = c   # Interpolates array @y into the list
-    # Perl5 prints:  x = 3   # Evaluates array @y in scalar context
-
-=item * C<sprintf()> prototyped as C<($;@)>
-
-C<sprintf()> is prototyped as ($;@), so its first argument is given scalar
-context. Thus, if passed an array, it will probably not do what you want,
-unlike Perl 4:
-
-    @z = ('%s%s', 'foo', 'bar');
-    $x = sprintf(@z);
-    print $x;
-
-    # perl4 prints: foobar
-    # perl5 prints: 3
-
-C<printf()> works the same as it did in Perl 4, though:
-
-    @z = ('%s%s', 'foo', 'bar');
-    printf STDOUT (@z);
-
-    # perl4 prints: foobar
-    # perl5 prints: foobar
-
-=back
-
-=head2 Precedence Traps
-
-Perl4-to-Perl5 traps involving precedence order.
-
-Perl 4 has almost the same precedence rules as Perl 5 for the operators
-that they both have.  Perl 4 however, seems to have had some
-inconsistencies that made the behavior differ from what was documented.
-
-=over 5
-
-=item * LHS vs. RHS of any assignment operator
-
-LHS vs. RHS of any assignment operator.  LHS is evaluated first
-in perl4, second in perl5; this can affect the relationship
-between side-effects in sub-expressions.
-
-    @arr = ( 'left', 'right' );
-    $a{shift @arr} = shift @arr;
-    print join( ' ', keys %a );
-
-    # perl4 prints: left
-    # perl5 prints: right
-
-=item * Semantic errors introduced due to precedence
-
-These are now semantic errors because of precedence:
-
-    @list = (1,2,3,4,5);
-    %map = ("a",1,"b",2,"c",3,"d",4);
-    $n = shift @list + 2;   # first item in list plus 2
-    print "n is $n, ";
-    $m = keys %map + 2;     # number of items in hash plus 2
-    print "m is $m\n";
-
-    # perl4 prints: n is 3, m is 6
-    # perl5 errors and fails to compile
-
-=item * Precedence of assignment operators same as the precedence of assignment
-
-The precedence of assignment operators is now the same as the precedence
-of assignment.  Perl 4 mistakenly gave them the precedence of the associated
-operator.  So you now must parenthesize them in expressions like
-
-    /foo/ ? ($a += 2) : ($a -= 2);
-
-Otherwise
-
-    /foo/ ? $a += 2 : $a -= 2
-
-would be erroneously parsed as
-
-    (/foo/ ? $a += 2 : $a) -= 2;
-
-On the other hand,
-
-    $a += /foo/ ? 1 : 2;
-
-now works as a C programmer would expect.
-
-=item * C<open> requires parentheses around filehandle
-
-    open FOO || die;
-
-is now incorrect.  You need parentheses around the filehandle.
-Otherwise, perl5 leaves the statement as its default precedence:
-
-    open(FOO || die);
-
-    # perl4 opens or dies
-    # perl5 opens FOO, dying only if 'FOO' is false, i.e. never
-
-=item * C<$:> precedence over C<$::> gone
-
-perl4 gives the special variable, C<$:> precedence, where perl5
-treats C<$::> as main C<package>
-
-    $a = "x"; print "$::a";
-
-    # perl 4 prints: -:a
-    # perl 5 prints: x
-
-=item * Precedence of file test operators documented
-
-perl4 had buggy precedence for the file test operators vis-a-vis
-the assignment operators.  Thus, although the precedence table
-for perl4 leads one to believe C<-e $foo .= "q"> should parse as
-C<((-e $foo) .= "q")>, it actually parses as C<(-e ($foo .= "q"))>.
-In perl5, the precedence is as documented.
-
-    -e $foo .= "q"
-
-    # perl4 prints: no output
-    # perl5 prints: Can't modify -e in concatenation
-
-=item * C<keys>, C<each>, C<values> are regular named unary operators
-
-In perl4, keys(), each() and values() were special high-precedence operators
-that operated on a single hash, but in perl5, they are regular named unary
-operators.  As documented, named unary operators have lower precedence
-than the arithmetic and concatenation operators C<+ - .>, but the perl4
-variants of these operators actually bind tighter than C<+ - .>.
-Thus, for:
-
-    %foo = 1..10;
-    print keys %foo - 1
-
-    # perl4 prints: 4
-    # perl5 prints: Type of arg 1 to keys must be hash (not subtraction)
-
-The perl4 behavior was probably more useful, if less consistent.
-
-=back
-
-=head2 General Regular Expression Traps using s///, etc.
-
-All types of RE traps.
-
-=over 5
-
-=item * C<s'$lhs'$rhs'> interpolates on either side
-
-C<s'$lhs'$rhs'> now does no interpolation on either side.  It used to
-interpolate $lhs but not $rhs.  (And still does not match a literal
-'$' in string)
-
-    $a=1;$b=2;
-    $string = '1 2 $a $b';
-    $string =~ s'$a'$b';
-    print $string,"\n";
-
-    # perl4 prints: $b 2 $a $b
-    # perl5 prints: 1 2 $a $b
-
-=item * C<m//g> attaches its state to the searched string
-
-C<m//g> now attaches its state to the searched string rather than the
-regular expression.  (Once the scope of a block is left for the sub, the
-state of the searched string is lost)
-
-    $_ = "ababab";
-    while(m/ab/g){
-        &doit("blah");
-    }
-    sub doit{local($_) = shift; print "Got $_ "}
-
-    # perl4 prints: Got blah Got blah Got blah Got blah
-    # perl5 prints: infinite loop blah...
-
-=item * C<m//o> used within an anonymous sub
-
-Currently, if you use the C<m//o> qualifier on a regular expression
-within an anonymous sub, I<all> closures generated from that anonymous
-sub will use the regular expression as it was compiled when it was used
-the very first time in any such closure.  For instance, if you say
-
-    sub build_match {
-        my($left,$right) = @_;
-        return sub { $_[0] =~ /$left stuff $right/o; };
-    }
-    $good = build_match('foo','bar');
-    $bad = build_match('baz','blarch');
-    print $good->('foo stuff bar') ? "ok\n" : "not ok\n";
-    print $bad->('baz stuff blarch') ? "ok\n" : "not ok\n";
-    print $bad->('foo stuff bar') ? "not ok\n" : "ok\n";
-
-For most builds of Perl5, this will print:
-ok
-not ok
-not ok
-
-build_match() will always return a sub which matches the contents of
-$left and $right as they were the I<first> time that build_match()
-was called, not as they are in the current call.
-
-=item * C<$+> isn't set to whole match
-
-If no parentheses are used in a match, Perl4 sets C<$+> to
-the whole match, just like C<$&>. Perl5 does not.
-
-    "abcdef" =~ /b.*e/;
-    print "\$+ = $+\n";
-
-    # perl4 prints: bcde
-    # perl5 prints:
-
-=item * Substitution now returns null string if it fails
-
-substitution now returns the null string if it fails
-
-    $string = "test";
-    $value = ($string =~ s/foo//);
-    print $value, "\n";
-
-    # perl4 prints: 0
-    # perl5 prints:
-
-Also see L<Numerical Traps> for another example of this new feature.
-
-=item * C<s`lhs`rhs`> is now a normal substitution
-
-C<s`lhs`rhs`> (using backticks) is now a normal substitution, with no
-backtick expansion
-
-    $string = "";
-    $string =~ s`^`hostname`;
-    print $string, "\n";
-
-    # perl4 prints: <the local hostname>
-    # perl5 prints: hostname
-
-=item * Stricter parsing of variables in regular expressions
-
-Stricter parsing of variables used in regular expressions
-
-    s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o;
-
-    # perl4: compiles w/o error
-    # perl5: with Scalar found where operator expected ..., near "$opt$plus"
-
-an added component of this example, apparently from the same script, is
-the actual value of the s'd string after the substitution.
-C<[$opt]> is a character class in perl4 and an array subscript in perl5
-
-    $grpc = 'a';
-    $opt  = 'r';
-    $_ = 'bar';
-    s/^([^$grpc]*$grpc[$opt]?)/foo/;
-    print;
-
-    # perl4 prints: foo
-    # perl5 prints: foobar
-
-=item * C<m?x?> matches only once
-
-Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched
-repeatedly, like C</x/> or C<m!x!>.
-
-    $test = "once";
-    sub match { $test =~ m?once?; }
-    &match();
-    if( &match() ) {
-        # m?x? matches more then once
-        print "perl4\n";
-    } else {
-        # m?x? matches only once
-        print "perl5\n";
-    }
-
-    # perl4 prints: perl4
-    # perl5 prints: perl5
-
-=item * Failed matches don't reset the match variables
-
-Unlike in Ruby, failed matches in Perl do not reset the match variables
-($1, $2, ..., C<$`>, ...).
-
-=back
-
-=head2 Subroutine, Signal, Sorting Traps
-
-The general group of Perl4-to-Perl5 traps having to do with
-Signals, Sorting, and their related subroutines, as well as
-general subroutine traps.  Includes some OS-Specific traps.
-
-=over 5
-
-=item * Barewords that used to look like strings look like subroutine calls
-
-Barewords that used to look like strings to Perl will now look like subroutine
-calls if a subroutine by that name is defined before the compiler sees them.
-
-    sub SeeYa { warn"Hasta la vista, baby!" }
-    $SIG{'TERM'} = SeeYa;
-    print "SIGTERM is now $SIG{'TERM'}\n";
-
-    # perl4 prints: SIGTERM is now main'SeeYa
-    # perl5 prints: SIGTERM is now main::1 (and warns "Hasta la vista, baby!")
-
-Use B<-w> to catch this one
-
-=item * Reverse is no longer allowed as the name of a sort subroutine
-
-reverse is no longer allowed as the name of a sort subroutine.
-
-    sub reverse{ print "yup "; $a <=> $b }
-    print sort reverse (2,1,3);
-
-    # perl4 prints: yup yup 123
-    # perl5 prints: 123
-    # perl5 warns (if using -w): Ambiguous call resolved as CORE::reverse()
-
-=item * C<warn()> won't let you specify a filehandle.
-
-Although it _always_ printed to STDERR, warn() would let you specify a
-filehandle in perl4.  With perl5 it does not.
-
-    warn STDERR "Foo!";
-
-    # perl4 prints: Foo!
-    # perl5 prints: String found where operator expected
-
-=back
-
-=head2 OS Traps
-
-=over 5
-
-=item * SysV resets signal handler correctly
-
-Under HPUX, and some other SysV OSes, one had to reset any signal handler,
-within  the signal handler function, each time a signal was handled with
-perl4.  With perl5, the reset is now done correctly.  Any code relying
-on the handler _not_ being reset will have to be reworked.
-
-Since version 5.002, Perl uses sigaction() under SysV.
-
-    sub gotit {
-        print "Got @_... ";
-    }
-    $SIG{'INT'} = 'gotit';
-
-    $| = 1;
-    $pid = fork;
-    if ($pid) {
-        kill('INT', $pid);
-        sleep(1);
-        kill('INT', $pid);
-    } else {
-        while (1) {sleep(10);}
-    }
-
-    # perl4 (HPUX) prints: Got INT...
-    # perl5 (HPUX) prints: Got INT... Got INT...
-
-=item * SysV C<seek()> appends correctly
-
-Under SysV OSes, C<seek()> on a file opened to append C<<< >> >>> now does
-the right thing w.r.t. the fopen() manpage. e.g., - When a file is opened
-for append,  it  is  impossible to overwrite information already in
-the file.
-
-    open(TEST,">>seek.test");
-    $start = tell TEST;
-    foreach(1 .. 9){
-        print TEST "$_ ";
-    }
-    $end = tell TEST;
-    seek(TEST,$start,0);
-    print TEST "18 characters here";
-
-    # perl4 (solaris) seek.test has: 18 characters here
-    # perl5 (solaris) seek.test has: 1 2 3 4 5 6 7 8 9 18 characters here
-
-
-
-=back
-
-=head2 Interpolation Traps
-
-Perl4-to-Perl5 traps having to do with how things get interpolated
-within certain expressions, statements, contexts, or whatever.
-
-=over 5
-
-=item * C<@> always interpolates an array in double-quotish strings
-
-@ now always interpolates an array in double-quotish strings.
-
-    print "To: someone@somewhere.com\n";
-
-    # perl4 prints: To:someone@somewhere.com
-    # perl < 5.6.1, error : In string, @somewhere now must be written as \@somewhere
-    # perl >= 5.6.1, warning : Possible unintended interpolation of @somewhere in string
-
-=item * Double-quoted strings may no longer end with an unescaped $
-
-Double-quoted strings may no longer end with an unescaped $.
-
-    $foo = "foo$";
-    print "foo is $foo\n";
-
-    # perl4 prints: foo is foo$
-    # perl5 errors: Final $ should be \$ or $name
-
-Note: perl5 DOES NOT error on the terminating @ in $bar
-
-=item * Arbitrary expressions are evaluated inside braces within double quotes
-
-Perl now sometimes evaluates arbitrary expressions inside braces that occur
-within double quotes (usually when the opening brace is preceded by C<$>
-or C<@>).
-
-    @www = "buz";
-    $foo = "foo";
-    $bar = "bar";
-    sub foo { return "bar" };
-    print "|@{w.w.w}|${main'foo}|";
-
-    # perl4 prints: |@{w.w.w}|foo|
-    # perl5 prints: |buz|bar|
-
-Note that you can C<use strict;> to ward off such trappiness under perl5.
-
-=item * C<$$x> now tries to dereference $x
-
-The construct "this is $$x" used to interpolate the pid at that point, but
-now tries to dereference $x.  C<$$> by itself still works fine, however.
-
-    $s = "a reference";
-    $x = *s;
-    print "this is $$x\n";
-
-    # perl4 prints: this is XXXx   (XXX is the current pid)
-    # perl5 prints: this is a reference
-
-=item * Creation of hashes on the fly with C<eval "EXPR"> requires protection
-
-Creation of hashes on the fly with C<eval "EXPR"> now requires either both
-C<$>'s to be protected in the specification of the hash name, or both curlies
-to be protected.  If both curlies are protected, the result will be compatible
-with perl4 and perl5.  This is a very common practice, and should be changed
-to use the block form of C<eval{}>  if possible.
-
-    $hashname = "foobar";
-    $key = "baz";
-    $value = 1234;
-    eval "\$$hashname{'$key'} = q|$value|";
-    (defined($foobar{'baz'})) ?  (print "Yup") : (print "Nope");
-
-    # perl4 prints: Yup
-    # perl5 prints: Nope
-
-Changing
-
-    eval "\$$hashname{'$key'} = q|$value|";
-
-to
-
-    eval "\$\$hashname{'$key'} = q|$value|";
-
-causes the following result:
-
-    # perl4 prints: Nope
-    # perl5 prints: Yup
-
-or, changing to
-
-    eval "\$$hashname\{'$key'\} = q|$value|";
-
-causes the following result:
-
-    # perl4 prints: Yup
-    # perl5 prints: Yup
-    # and is compatible for both versions
-
-
-=item * Bugs in earlier perl versions
-
-perl4 programs which unconsciously rely on the bugs in earlier perl versions.
-
-    perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"'
-
-    # perl4 prints: This is not perl5
-    # perl5 prints: This is perl5
-
-=item * Array and hash brackets during interpolation
-
-You also have to be careful about array and hash brackets during
-interpolation.
-
-    print "$foo["
-
-    perl 4 prints: [
-    perl 5 prints: syntax error
-
-    print "$foo{"
-
-    perl 4 prints: {
-    perl 5 prints: syntax error
-
-Perl 5 is expecting to find an index or key name following the respective
-brackets, as well as an ending bracket of the appropriate type.  In order
-to mimic the behavior of Perl 4, you must escape the bracket like so.
-
-    print "$foo\[";
-    print "$foo\{";
-
-=item * Interpolation of C<\$$foo{bar}>
-
-Similarly, watch out for: C<\$$foo{bar}>
-
-    $foo = "baz";
-    print "\$$foo{bar}\n";
-
-    # perl4 prints: $baz{bar}
-    # perl5 prints: $
-
-Perl 5 is looking for C<$foo{bar}> which doesn't exist, but perl 4 is
-happy just to expand $foo to "baz" by itself.  Watch out for this
-especially in C<eval>'s.
-
-=item * C<qq()> string passed to C<eval> will not find string terminator
-
-C<qq()> string passed to C<eval>
-
-    eval qq(
-        foreach \$y (keys %\$x\) {
-            \$count++;
-        }
-    );
-
-    # perl4 runs this ok
-    # perl5 prints: Can't find string terminator ")"
-
-=back
-
-=head2 DBM Traps
-
-General DBM traps.
-
-=over 5
-
-=item * Perl5 must have been linked with same dbm/ndbm as the default for C<dbmopen()>
-
-Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
-may cause the same script, run under perl5, to fail.  The build of perl5
-must have been linked with the same dbm/ndbm as the default for C<dbmopen()>
-to function properly without C<tie>'ing to an extension dbm implementation.
-
-    dbmopen (%dbm, "file", undef);
-    print "ok\n";
-
-    # perl4 prints: ok
-    # perl5 prints: ok (IFF linked with -ldbm or -lndbm)
-
-
-=item * DBM exceeding limit on the key/value size will cause perl5 to exit immediately
-
-Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
-may cause the same script, run under perl5, to fail.  The error generated
-when exceeding the limit on the key/value size will cause perl5 to exit
-immediately.
-
-    dbmopen(DB, "testdb",0600) || die "couldn't open db! $!";
-    $DB{'trap'} = "x" x 1024;  # value too large for most dbm/ndbm
-    print "YUP\n";
-
-    # perl4 prints:
-    dbm store returned -1, errno 28, key "trap" at - line 3.
-    YUP
-
-    # perl5 prints:
-    dbm store returned -1, errno 28, key "trap" at - line 3.
-
-=back
-
-=head2 Unclassified Traps
-
-Everything else.
-
-=over 5
-
-=item * C<require>/C<do> trap using returned value
-
-If the file doit.pl has:
-
-    sub foo {
-        $rc = do "./do.pl";
-        return 8;
-    }
-    print &foo, "\n";
-
-And the do.pl file has the following single line:
-
-    return 3;
-
-Running doit.pl gives the following:
-
-    # perl 4 prints: 3 (aborts the subroutine early)
-    # perl 5 prints: 8
-
-Same behavior if you replace C<do> with C<require>.
-
-=item * C<split> on empty string with LIMIT specified
-
-    $string = '';
-    @list = split(/foo/, $string, 2)
-
-Perl4 returns a one element list containing the empty string but Perl5
-returns an empty list.
-
-=back
-
 As always, if any of these are ever officially declared as bugs,
 they'll be fixed and removed.