The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
 / 
perl-5.35.9
River stage five • 11292 direct dependents • 32664 total dependents
419 ++
/ perldelta

NAME

perldelta - what is new for perl v5.35.9

DESCRIPTION

This document describes differences between the 5.35.8 release and the 5.35.9 release.

If you are upgrading from an earlier release such as 5.35.7, first read perl5358delta, which describes differences between 5.35.7 and 5.35.8.

Core Enhancements

Subroutine signatures are no longer experimental

Introduced in Perl version 5.20.0, and modified several times since, the subroutine signatures feature (use feature 'signatures') is now no longer considered experimental. It is now considered a stable language feature and is included in the :5.36 feature bundle, enabled automatically by use v5.36, and no longer prints a warning.

    use v5.36;

    sub add ($x, $y) {
      return $x + $y;
    }

Despite this, certain elements of signatured subroutines remain experimental; see below.

@_ is now experimental within signatured subs

Even though subroutine signatures are now stable, use of the default arguments array (@_) with a subroutine that has a signature remains experimental, with its own warning category. Silencing the experimental::signatures warning category is not sufficient to dismiss this. The new warning is emitted with the category name experimental::args_array_with_signatures.

Any subroutine that has a signature and tries to make use of the defaults argument array or an element thereof (@_ or $_[INDEX]), either explicitly or implicitly (such as shift or pop with no argument) will provoke a warning at compile-time:

    use v5.36;

    sub f ($x, $y = 123) {
      say "The first argument is $_[0]";
    }

    Use of @_ in array element with signatured subroutine is experimental
    at file.pl line 4.

The behaviour of code which attempts to do this is no longer specified, and may be subject to change in a future version.

The isa operator is no longer experimental

Introduced in Perl version 5.32.0, this operator has remained unchanged since then. The operator is now considered a stable language feature and is included in the :5.36 feature bundle, enabled automatically by use v5.36.

For more detail see "Class Instance Operator" in perlop.

-g command-line flag

A new command-line flag, -g, is available. It is a simpler alias for -0777.

For more information, see "-g" in perlrun.

Deprecations

Downgrading a use VERSION statement to below v5.11

Attempting to issue a second use VERSION statement that requests a version lower than v5.11 when an earlier statement that requested a version at least v5.11 has already been seen, will now print a deprecation warning.

For example:

    use v5.14;
    say "The say statement is permitted";
    use v5.8;                               # This will print a warning
    print "We must use print\n";

This is because of an intended related change to the interaction between use VERSION and use strict. If you specify a version >= 5.11, strict is enabled implicitly. If you request a version < 5.11, strict will become disabled even if you had previously written use strict. This was not the previous behaviour of use VERSION, which at present will track explicitly-enabled strictness flags independently.

Code which wishes to mix versions in this manner should use lexical scoping with block syntax to ensure that the differently versioned regions remain lexically isolated.

    {
        use v5.14;
        say "The say statement is permitted";
    }
    {
        use v5.8;                           # No warning is emitted
        print "We must use print\n";
    }

Modules and Pragmata

Updated Modules and Pragmata

  • B::Deparse has been upgraded from version 1.61 to 1.62.

  • charnames has been upgraded from version 1.49 to 1.50.

  • CPAN has been upgraded from version 2.29 to 2.33.

  • Devel::PPPort has been upgraded from version 3.63 to 3.64.

  • experimental has been upgraded from version 0.025 to 0.027.

  • feature has been upgraded from version 1.69 to 1.70.

  • File::Copy has been upgraded from version 2.38 to 2.39.

  • Hash::Util has been upgraded from version 0.27 to 0.28.

  • Hash::Util::FieldHash has been upgraded from version 1.25 to 1.26.

  • Module::CoreList has been upgraded from version 5.20220120 to 5.20220220.

  • Opcode has been upgraded from version 1.55 to 1.56.

  • overload has been upgraded from version 1.34 to 1.35.

  • re has been upgraded from version 0.41 to 0.42.

  • Scalar::Util has been upgraded from version 1.60 to 1.61.

  • sigtrap has been upgraded from version 1.09 to 1.10.

  • Tie::SubstrHash has been upgraded from version 1.00 to 1.01.

  • warnings has been upgraded from version 1.56 to 1.57.

  • XS::APItest has been upgraded from version 1.20 to 1.21.

Diagnostics

New Diagnostics

New Warnings

Changes to Existing Diagnostics

Internal Changes

  • New equality-test functions sv_numeq and sv_streq have been added, along with ..._flags-suffixed variants. These expose a simple and consistent API to perform numerical or string comparison which is aware of operator overloading.

  • Reading the string form of an integer value no longer sets the flag SVf_POK. The string form is still cached internally, and still re-read directly by the macros SvPV(sv) etc (inline, without calling a C function). XS code that already calls the APIs to get values will not be affected by this change. XS code that accesses flags directly instead of using API calls to express its intent might break, but such code likely is already buggy if passed some other values, such as floating point values or objects with string overloading.

    This small change permits code (such as JSON serializers) to reliably determine between

    • a value that was initially written as an integer, but then read as a string

          my $answer = 42;
    print "The answer is $answer\n";

    • that same value that was initially written as a string, but then read as an integer

          my $answer = "42";
    print "That doesn't look right\n"
        unless $answer == 6 * 9;

    For the first case (originally written as an integer), we now have:

        use Devel::Peek;
    my $answer = 42;
    Dump ($answer);
    my $void = "$answer";
    print STDERR "\n";
    Dump($answer)


    SV = IV(0x562538925778) at 0x562538925788
      REFCNT = 1
      FLAGS = (IOK,pIOK)
      IV = 42

    SV = PVIV(0x5625389263c0) at 0x562538925788
      REFCNT = 1
      FLAGS = (IOK,pIOK,pPOK)
      IV = 42
      PV = 0x562538919b50 "42"\0
      CUR = 2
      LEN = 10

    For the second (originally written as a string), we now have:

        use Devel::Peek;
    my $answer = "42";
    Dump ($answer);
    my $void = $answer == 6 * 9;
    print STDERR "\n";
    Dump($answer)'


    SV = PV(0x5586ffe9bfb0) at 0x5586ffec0788
      REFCNT = 1
      FLAGS = (POK,IsCOW,pPOK)
      PV = 0x5586ffee7fd0 "42"\0
      CUR = 2
      LEN = 10
      COW_REFCNT = 1

    SV = PVIV(0x5586ffec13c0) at 0x5586ffec0788
      REFCNT = 1
      FLAGS = (IOK,POK,IsCOW,pIOK,pPOK)
      IV = 42
      PV = 0x5586ffee7fd0 "42"\0
      CUR = 2
      LEN = 10
      COW_REFCNT = 1

    (One can't rely on the presence or absence of the flag SVf_IsCOW to determine the history of operations on a scalar.)

    Previously both cases would be indistinguishable, with all 4 flags set:

        SV = PVIV(0x55d4d62edaf0) at 0x55d4d62f0930
      REFCNT = 1
      FLAGS = (IOK,POK,pIOK,pPOK)
      IV = 42
      PV = 0x55d4d62e1740 "42"\0
      CUR = 2
      LEN = 10

    (and possibly SVf_IsCOW, but not always)

    This now means that if XS code really needs to determine which form a value was first written as, it should implement logic roughly

        if (flags & SVf_IOK|SVf_NOK) && !(flags & SVf_POK)
        serialize as number
    else if (flags & SVf_POK)
        serialize as string
    else
        the existing guesswork ...

    Note that this doesn't cover "dualvars" - scalars that report different values when asked for their string form or number form (such as $!). Most serialization formats cannot represent such duplicity.

    The existing guesswork remains because as well as dualvars, values might be undef, references, overloaded references, typeglobs and other things that Perl itself can represent but do not map one-to-one into external formats, so need some amount of approximation or encapsulation.

  • Memory for hash iterator state (struct xpvhv_aux) is now allocated as part of the hash body, instead of as part of the block of memory allocated for the main hash array.

    Nothing else changes - memory for this structure is still allocated only when needed, is still accessed via the HvAUX() macro, and the macro should only be called when SvOOK() is true. Hashes are still always of type SVt_PVHV, hash bodies are still allocated from arenas, and the address of the hash doesn't change, because the address is the pointer to the head structure, which never moves.

    Internally, a second arena (the arena with index 1) is used to allocate larger bodies with space for struct xpvhv_aux, the body "upgraded", and the "head" structure updated to reflect this (much the same way that the bodies of scalars are upgraded). We already re-purpose arenas - arena with index 0 is used for HE *s.

    None of this affects documented public XS interfaces. The only code changes are in hv.c and sv.c. As the rest of the core itself uses these macros but needed no changes, likely no code on CPAN will be affected either.

Acknowledgements

Perl 5.35.9 represents approximately 4 weeks of development since Perl 5.35.8 and contains approximately 8,700 lines of changes across 280 files from 22 authors.

Excluding auto-generated files, documentation and release tools, there were approximately 3,000 lines of changes to 110 .pm, .t, .c and .h files.

Perl continues to flourish into its fourth decade thanks to a vibrant community of users and developers. The following people are known to have contributed the improvements that became Perl 5.35.9:

Branislav Zahradník, Christopher Yeleighton, Dagfinn Ilmari Mannsåker, Dave Cross, David Cantrell, Hugo van der Sanden, James E Keenan, James Raspass, Karl Williamson, Leon Timmermans, Max Maischein, Michiel Beijen, Nicholas Clark, Nicolas R., Paul Evans, Renee Baecker, Ricardo Signes, Sergey Zhmylove, TAKAI Kousuke, Tomasz Konojacki, Tony Cook, Yves Orton.

The list above is almost certainly incomplete as it is automatically generated from version control history. In particular, it does not include the names of the (very much appreciated) contributors who reported issues to the Perl bug tracker.

Many of the changes included in this version originated in the CPAN modules included in Perl's core. We're grateful to the entire CPAN community for helping Perl to flourish.

For a more complete list of all of Perl's historical contributors, please see the AUTHORS file in the Perl source distribution.

Reporting Bugs

If you find what you think is a bug, you might check the perl bug database at https://github.com/Perl/perl5/issues. There may also be information at http://www.perl.org/, the Perl Home Page.

If you believe you have an unreported bug, please open an issue at https://github.com/Perl/perl5/issues. Be sure to trim your bug down to a tiny but sufficient test case.

If the bug you are reporting has security implications which make it inappropriate to send to a public issue tracker, then see "SECURITY VULNERABILITY CONTACT INFORMATION" in perlsec for details of how to report the issue.

Give Thanks

If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, you can do so by running the perlthanks program:

    perlthanks

This will send an email to the Perl 5 Porters list with your show of thanks.

SEE ALSO

The Changes file for an explanation of how to view exhaustive details on what changed.

The INSTALL file for how to build Perl.

The README file for general stuff.

The Artistic and Copying files for copyright information.