Perl 5.33.1 repairs nonblocking waits on Windows

A nonblocking child-process check is useful because the caller can continue when no child has exited. An unexpectedly long timeout violates that purpose even if the eventual process status is correct. Perl 5.33.1 repairs a Win32 case in which waitpid(-1, WNOHANG) could have a very large timeout. This is a timing correction to an existing interface, not a new way to launch or supervise processes.

The snapshot's release notes identify that call explicitly. The tagged history file records August 20 as the release date. Other changes include a repair for over-optimized list assignments and a new way to disable an older hash syntax. Each concerns behavior that a short expression can otherwise leave implicit.

Nonblocking waits have several distinct results

The waitpid reference in this release describes the interface in terms of both the selected child and the wait flags. A PID of -1 selects any child process. With WNOHANG, a return value of zero means matching children exist but none has terminated yet. A positive result identifies a terminated child, while -1 indicates that no such child exists, subject to the documented qualification about automatic reaping on some systems.

Those results support different decisions by the caller. No completed child yet is not the same condition as no child remaining to wait for. The exit status also lives separately in $? and ${^CHILD_ERROR_NATIVE}. Conflating the return value with the child's status would misinterpret the interface even after the timeout repair.

The reference supplies this form for collecting pending completed children without blocking:

use POSIX ':sys_wait_h';

my $kid;
do {
    $kid = waitpid(-1, WNOHANG);
} while $kid > 0;

The loop continues while it collects positive process identifiers. It stops when the call reports that no further completed child is available under those conditions. The example does not claim to be a complete process supervisor. Its purpose is to show the nonblocking operation whose timing contract makes the Win32 repair important.

I prefer compact Perl for occasional automation, where process handling can sit next to text processing in a small script. A nonblocking operation needs predictable meaning there. A caller should not have to reinterpret a long pause as normal behavior merely because the function eventually supplies a plausible return value.

An unused destination can still affect an assignment

The same release fixes some list assignments with undef on the left-hand side that an optimization handled incorrectly. This is a different correctness problem. A discarded destination does not necessarily make every value associated with that position irrelevant to the surrounding expression. The assignment's result can itself be consumed by other code.

The reported regression demonstrates a variable appearing on both sides of an assignment, with undef occupying another destination. The reporter observed different returned list contents between interpreter versions. Replacing the discarded destination with an otherwise unused variable avoided the problem. This gives a specific application-visible case for the release note's description of over-optimization.

The broader implication is about preserving the original right-hand values when the assignment also overwrites one of their source variables. An optimization cannot infer that discarding a destination makes those values unnecessary everywhere. A surrounding expression may still need them. This is why testing only the variable that receives an assignment can miss a bug in the value returned by the assignment itself.

Older hash syntax gains a lexical control

The updated feature module adds multidimensional, enabled by default. Its bundled documentation explains that the facility emulates multidimensional arrays with hashes. A comma-separated key list becomes a single key by joining its components with $;. Disabling the feature causes the normally transformed syntax to fail compilation.

This differs from a hash whose values are references to other hashes. Emulation constructs one key using a separator, so the representation's identity rules depend on that construction. The feature control lets source code reject this older form explicitly without changing its default availability for existing programs. It is a way to constrain accepted syntax within a lexical scope.

The notes also improve uninitialized-value warnings for missing array or hash elements. The warning can now include the index when that index is a simple, non-magical variable. That qualification is part of the behavior. It avoids suggesting that every complex or magical index expression receives an equally detailed diagnostic in this snapshot.

My interest in such controls is the ability to make an intended style enforceable by the interpreter. Documentation alone cannot stop an expression from acquiring the older interpretation. August's snapshot provides a concrete switch for that case while independently repairing process-wait timing and list-assignment results. Maintainers can therefore identify which change affects their code without treating every item as part of one generalized modernization effort.