X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperl5110delta.pod;h=b4c2cdcf8335fd74e44b055b3c94cc85ca6a6fc1;hb=02569b83981ae18ebfaeeac6872f94b7afd6e5a6;hp=91b96822daa029201a5d7ac61259261f142cec6a;hpb=54ad55c59e2227f3197e56a9a85b1f78d0229ac7;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perl5110delta.pod b/pod/perl5110delta.pod index 91b9682..b4c2cdc 100644 --- a/pod/perl5110delta.pod +++ b/pod/perl5110delta.pod @@ -5,14 +5,180 @@ perldelta - what is new for perl v5.11.0 =head1 DESCRIPTION This document describes differences between the 5.10.0 and the 5.11.0 -developement releases. +development releases. =head1 Incompatible Changes +=head2 Switch statement changes + +The handling of complex expressions by the C/C switch +statement has been enhanced. There are two new cases where C now +interprets its argument as a boolean, instead of an expression to be used +in a smart match: + +=over 4 + +=item flip-flop operators + +The C<..> and C<...> flip-flop operators are now evaluated in boolean +context, following their usual semantics; see L. + +Note that, as in perl 5.10.0, C will not work to test +whether a given value is an integer between 1 and 10; you should use +C instead (note the array reference). + +However, contrary to 5.10.0, evaluating the flip-flop operators in boolean +context ensures it can now be useful in a C, notably for +implementing bistable conditions, like in: + + when (/^=begin/ .. /^=end/) { ... } + +=item defined-or operator + +A compound expression involving the defined-or operator, as in +C, will be treated as boolean if the first +expression is boolean. (This just extends the existing rule that applies +to the regular or operator, as in C.) + +=back + +The next section details more changes brought to the semantics to +the smart match operator, that naturally also modify the behaviour +of the switch statements where smart matching is implicitly used. + +=head2 Smart match changes + +=head3 Changes to type-based dispatch + +The smart match operator C<~~> is no longer commutative. The behaviour of +a smart match now depends primarily on the type of its right hand +argument. Moreover, its semantics has been adjusted for greater +consistency or usefulness in several cases. While the general backwards +compatibility is maintained, several changes must be noted: + +=over 4 + +=item * + +Code references with an empty prototype are no longer treated specially. +They are passed an argument like the other code references (even if they +choose to ignore it). + +=item * + +C<%hash ~~ sub {}> and C<@array ~~ sub {}> now test that the subroutine +returns a true value for each key of the hash (or element of the +array), instead of passing the whole hash or array as a reference to +the subroutine. + +=item * + +Due to the commutativity breakage, code references are no longer +treated specially when appearing on the left of the C<~~> operator, +but like any vulgar scalar. + +=item * + +C is always false (since C can't be a key in a +hash). No implicit conversion to C<""> is done (as was the case in perl +5.10.0). + +=item * + +C<$scalar ~~ @array> now always distributes the smart match across the +elements of the array. It's true if one element in @array verifies +C<$scalar ~~ $element>. This is a generalization of the old behaviour +that tested whether the array contained the scalar. + +=back + +The full dispatch table for the smart match operator is given in +L. + +=head3 Smart match and overloading + +According to the rule of dispatch based on the rightmost argument type, +when an object overloading C<~~> appears on the right side of the +operator, the overload routine will always be called (with a 3rd argument +set to a true value, see L.) However, when the object will +appear on the left, the overload routine will be called only when the +rightmost argument is a simple scalar. This way distributivity of smart match +across arrays is not broken, as well as the other behaviours with complex +types (coderefs, hashes, regexes). Thus, writers of overloading routines +for smart match mostly need to worry only with comparing against a scalar, +and possibly with stringification overloading; the other common cases +will be automatically handled consistently. + +C<~~> will now refuse to work on objects that do not overload it (in order +to avoid relying on the object's underlying structure). (However, if the +object overloads the stringification or the numification operators, and +if overload fallback is active, it will be used instead, as usual.) + =head1 Core Enhancements +=head2 The C pragma + +This pragma allows you to lexically disable or enable overloading +for some or all operations. (Yuval Kogman) + +=head2 C<\N> regex escape + +A new regex escape has been added, C<\N>. It will match any character that +is not a newline, independently from the presence or absence of the single +line match modifier C. (If C<\N> is followed by an opening brace and +by a letter, perl will still assume that a Unicode character name is +coming, so compatibility is preserved.) (Rafael Garcia-Suarez) + +=head2 Implicit strictures + +Using the C syntax with a version number greater or equal +to 5.11.0 will also lexically enable strictures just like C +would do (in addition to enabling features.) So, the following: + + use 5.11.0; + +will now imply: + + use strict; + use feature ':5.11'; + +=head2 Parallel tests + +The core distribution can now run its regression tests in parallel on +Unix-like platforms. Instead of running C, set C in +your environment to the number of tests to run in parallel, and run +C. On a Bourne-like shell, this can be done as + + TEST_JOBS=3 make test_harness # Run 3 tests in parallel + +An environment variable is used, rather than parallel make itself, because +L needs to be able to schedule individual non-conflicting test +scripts itself, and there is no standard interface to C utilities to +interact with their job schedulers. + =head1 Modules and Pragmata +=head2 Pragmata Changes + +=over 4 + +=item C + +See L pragma"> above. + +=back + +=head2 Selected Changes to Core Modules + +=over 4 + +L now includes all the necessary code to function. Previously, it +used to be a lightweight placeholder that loaded the actual code from +C on demand. C is now a simple, empty module +kept for backwards compatibility for programs that used to pre-load it. + +=back + =head1 Utility Changes =head1 Documentation @@ -30,6 +196,13 @@ developement releases. as documented, and as does C<-I> when specified on the command-line. (Renée Bäcker) +=item C is now fatal when called on non-numeric process identifiers + +Previously, an 'undef' process identifier would be interpreted as a request to +kill process "0", which would terminate the current process group on POSIX +systems. Since process identifiers are always integers, killing a non-numeric +process is now fatal. + =back =head1 New or Changed Diagnostics @@ -53,6 +226,15 @@ to a tiny but sufficient test case. Your bug report, along with the output of C, will be sent off to perlbug@perl.org to be analysed by the Perl porting team. +If the bug you are reporting has security implications, which make it +inappropriate to send to a publicly archived mailing list, then please send +it to perl5-security-report@perl.org. This points to a closed subscription +unarchived mailing list, which includes all the core committers, who be able +to help assess the impact of issues, figure out a resolution, and help +co-ordinate the release of patches to mitigate or fix the problem across all +platforms on which Perl is supported. Please only use this address for security +issues in the Perl core, not for modules independently distributed on CPAN. + =head1 SEE ALSO The F file for exhaustive details on what changed.