PERLDEPRECATION(1)

📦
version 5.42.3 · 22 versions
, in fedora 43, fedora 44

✨ NAME ✨

perldeprecation — the official tea-spilling doc from the Perl Programmers Reference Guide, aka manual page PERLDEPRECATION(1), where Perl tells you, bestie to bestie, exactly which features are on their way out 💅

💖 DESCRIPTION 💖

okay so the whole point of this document is to keep receipts 📝 on what has been deprecated in Perl, and by which version the deprecated feature is gonna disappear — or, for the ones already gone, when it got removed. periodt.

It also tries to talk about what alternatives exist for the deprecated stuff, because we're not just gonna take things away and leave you hanging 🫶

The deprecated features are grouped by the version of Perl in which they will be removed. iconic organization, no notes.

🦋 Unscheduled Deprecations

Unicode Delimiter Will be Paired

So some Unicode delimiters used to be allowed as single characters, but in the future they're gonna be part of a balanced pair. This deprecation category marks the ones that will flip from being unpaired to paired.

Category: deprecated::delimiter_will_be_paired

Dot In Inc

The current working directory "." used to be automatically included in @INC, but in Perl 5.26 this got removed for security reasons 😭 Ever since then, Perl produces a warning when a user uses do EXPR and EXPR does not include a path, and the file wasn't found in any directory in @INC but was located in ".". The file will not be loaded, but a deprecated warning will be generated.

Category: deprecated::dot_in_inc

Unicode Property Name

Various types of Unicode property name will generate deprecated warnings when used in a regex pattern. For instance surrogate characters will result in deprecation warnings.

Category: deprecated::unicode_property_name

💜 Perl 5.44

Calling a missing import() or unimport() method with an argument

Historically, calling import() or unimport() on any class which did not define such a method would be silently ignored. Effectively Perl behaved as though there was an empty method defined in the UNIVERSAL package (even when there was no such method actually defined 🙈). As of Perl version 5.39.2, calling such a method with an argument will trigger a warning, and in Perl version 5.44 this warning will be upgraded to an error. (Calling such a method with no arguments at all will always be safe. 🫶)

Category: deprecated::missing_import_called_with_args

Changing use VERSION while another use VERSION is in scope

A use VERSION declaration has so many implicit effects on the surrounding scope — strict and feature flags, importing builtin functions, the whole vibe. Once you have a use VERSION statement in scope, another use VERSION statement with a different version is now deprecated since Perl 5.39.8, because swapping from one prevailing version to another got way too complicated. it's giving chaos 💀

Category: deprecated::subsequent_use_version

🌸 Perl 5.42

Goto Block Construct

goto LABEL; will produce a deprecated warning when jumping into the body of a loop or other block construct from outside. For instance:

while (should_loop($x)) {
    LABEL:
        do_stuff();
}
goto LABEL;

...will produce a warning that this behavior is deprecated. In general you should just avoid doing this; the people that maintain your code will be grateful for your restraint 🙏

Category: deprecated::goto_construct

🎀 Perl 5.40

Downgrading a use VERSION to below v5.11

Once Perl has seen a use VERSION declaration that requests a version v5.11 or above, a subsequent second declaration that requests an earlier version will print a deprecation warning. For example:

use v5.14;
say "We can use v5.14's features here";

use v5.10;        # This prints a warning

This was deprecated in Perl 5.36 and is now fatal 💀

Why tho? 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.

Category: deprecated::version_downgrade

🌈 Perl 5.38

Pod::Html utility functions

The definition and documentation of three utility functions previously importable from Pod::Html were moved to the new package Pod::Html::Util in Perl 5.36. While they remained importable from Pod::Html in Perl 5.36, as of Perl 5.38 they are only importable, on request, from Pod::Html::Util.

⭐ Perl 5.34

There were no deprecations or fatalizations in Perl 5.34. a peaceful era. we love a quiet release 💖

🦋 Perl 5.32

Constants from lexical variables potentially modified elsewhere

You wrote something like:

my $var;
$sub = sub () { $var };

...but $var is referenced elsewhere and could be modified after the sub expression is evaluated. Either it is explicitly modified elsewhere ($var = 3) or it is passed to a subroutine or to an operator like printf or map, which may or may not modify the variable.

Traditionally, Perl has captured the value of the variable at that point and turned the subroutine into a constant eligible for inlining. But in those cases where the variable can be modified elsewhere, this breaks the behavior of closures, in which the subroutine captures the variable itself rather than its value — so future changes to the variable are reflected in the subroutine's return value.

If you intended for the subroutine to be eligible for inlining, then make sure the variable is not referenced elsewhere, possibly by copying it:

my $var2 = $var;
$sub = sub () { $var2 };

If you do want this subroutine to be a closure that reflects future changes to the variable that it closes over, add an explicit return:

my $var;
$sub = sub () { return $var };

This usage was deprecated and as of Perl 5.32 is no longer allowed.

Use of strings with code points over 0xFF as arguments to vec

vec views its string argument as a sequence of bits. A string containing a code point over 0xFF is nonsensical. This usage is deprecated in Perl 5.28, and was removed in Perl 5.32.

Use of code points over 0xFF in string bitwise operators

The string bitwise operators, &, |, ^, and ~, treat their operands as strings of bytes. As such, values above 0xFF are nonsensical. Some instances of these have been deprecated since Perl 5.24, and were made fatal in 5.28, but it turns out that in cases where the wide characters did not affect the end result, no deprecation notice was raised, and so remain legal. Now, all occurrences either are fatal or raise a deprecation warning, so that the remaining legal occurrences became fatal in 5.32.

An example of this is:

"" & "\x{100}"

The wide character is not used in the & operation because the left operand is shorter. This now throws an exception 💀

hostname() doesn't accept any arguments

The function hostname() in the Sys::Hostname module has always been documented to be called with no arguments. Historically it has not enforced this, and has actually accepted and ignored any arguments. As a result, some users have got the mistaken impression that an argument does something useful 🙈 To avoid these bugs, the function is being made strict. Passing arguments was deprecated in Perl 5.28 and became fatal in Perl 5.32.

Unescaped left braces in regular expressions

The simple rule to remember, if you want to match a literal { character (U+007B LEFT CURLY BRACKET) in a regular expression pattern, is to escape each literal instance of it in some way. Generally easiest is to precede it with a backslash, like \{ or enclose it in square brackets ([{]). If the pattern delimiters are also braces, any matching right brace (}) should also be escaped to avoid confusing the parser, for example:

qr{abc\{def\}ghi}

Forcing literal { characters to be escaped will enable the Perl language to be extended in various ways in future releases. To avoid needlessly breaking existing code, the restriction is not enforced in contexts where there are unlikely to ever be extensions that could conflict with the use of { as a literal. A non-deprecation warning that the left brace is being taken literally is raised in contexts where there could be confusion about it.

Literal uses of { were deprecated in Perl 5.20, and some uses of it started to give deprecation warnings since. These cases were made fatal in Perl 5.26. Due to an oversight, not all cases of a use of a literal { got a deprecation warning. Some cases started warning in Perl 5.26, and were made fatal in Perl 5.30. Other cases started in Perl 5.28, and were made fatal in 5.32.

In XS code, use of various macros dealing with UTF-8

The macros below now require an extra parameter compared to versions prior to Perl 5.32. The final parameter in each one is a pointer into the string supplied by the first parameter beyond which the input will not be read. This prevents potential reading beyond the end of the buffer. The macros are:

isALPHANUMERIC_utf8, isASCII_utf8, isBLANK_utf8, isCNTRL_utf8, isDIGIT_utf8, isIDFIRST_utf8, isPSXSPC_utf8, isSPACE_utf8, isVERTWS_utf8, isWORDCHAR_utf8, isXDIGIT_utf8, isALPHANUMERIC_LC_utf8, isALPHA_LC_utf8, isASCII_LC_utf8, isBLANK_LC_utf8, isCNTRL_LC_utf8, isDIGIT_LC_utf8, isGRAPH_LC_utf8, isIDCONT_LC_utf8, isIDFIRST_LC_utf8, isLOWER_LC_utf8, isPRINT_LC_utf8, isPSXSPC_LC_utf8, isPUNCT_LC_utf8, isSPACE_LC_utf8, isUPPER_LC_utf8, isWORDCHAR_LC_utf8, isXDIGIT_LC_utf8, toFOLD_utf8, toLOWER_utf8, toTITLE_utf8, and toUPPER_utf8.

Since Perl 5.26, this functionality with the extra parameter has been available by using a corresponding macro to each one of these, and whose name is formed by appending _safe to the base name. There is no change to the functionality of those. For example, isDIGIT_utf8_safe corresponds to isDIGIT_utf8, and both now behave identically. All are documented in "Character case changing" in perlapi and "Character classification" in perlapi.

This change was originally scheduled for 5.30, but was delayed until 5.32. classic.

File::Glob::glob() was removed

File::Glob had a function called glob, which just called bsd_glob.

File::Glob::glob() was deprecated in Perl 5.8. A deprecation message was issued from Perl 5.26 onwards, the function became fatal in Perl 5.30, and was removed entirely in Perl 5.32.

Code using File::Glob::glob() should call File::Glob::bsd_glob() instead. 🫶

💀 Perl 5.30

$* is no longer supported

Before Perl 5.10, setting $* to a true value globally enabled multi-line matching within a string. This relic from the past lost its special meaning in 5.10. Use of this variable became a fatal error in Perl 5.30, freeing the variable up for a future special meaning.

To enable multiline matching, bestie, you wanna use the "/m" regexp modifier (and honestly, maybe pair it with "/s" while you're at it 💅). You can flip it on per-match, or per lexical scope — yes, even for a whole file — with use re '/m'.

💀 $# is no longer supported 💀

So this variable used to have a special meaning — it could control how numbers got formatted when printed. That whole thing got removed in Perl 5.10, no cap. And then, to free the variable up for some future special meaning, using it became a fatal error in Perl 5.30. 😭

Wanna control how numbers print? The advice is literally just use printf or sprintf instead. Periodt.

🚨 Assigning non-zero to $[ is fatal 🚨

This variable (plus the matching array_base feature and arybase module) let you change the base for array and string indexing operations. Iconic in its day, super illegal now.

Setting it to a non-zero value has been deprecated since Perl 5.12 and throws a fatal error as of Perl 5.30. Bye bestie 🫶

🗑️ Unqualified dump() 🗑️

Using dump() instead of CORE::dump() got deprecated in Perl 5.8, and an unqualified dump() is no longer available as of Perl 5.30.

See dump in perlfunc for the real tea.

🌸 Using my() in false conditional 🌸

Okay so there's been a long-standing bug in Perl where a lexical variable doesn't get cleared at scope exit when its declaration includes a false conditional. And some people <em>exploited</em> this bug to fake a static variable. To let the perl devs actually fix this bug, we all gotta stop relying on that behavior, okay? 😤

Instead, it's recommended you use state variables to get the same effect:

use 5.10.0;
sub count {state $counter; return ++ $counter}
say count ();    # Prints 1
say count ();    # Prints 2

state variables were introduced in Perl 5.10. ✨

Alternatively, you can get a similar static effect by declaring the variable in a separate block outside the function, like:

sub f { my $x if 0; return $x++ }

becomes

{ my $x; sub f { return $x++ } }

Using my() in a false conditional got deprecated in Perl 5.10, and became a fatal error in Perl 5.30. No more sneaky static variables, bestie. 💅

🔥 Reading/writing bytes from/to :utf8 handles 🔥

The sysread(), recv(), syswrite() and send() operators are deprecated on handles that have the ":utf8" layer — whether you asked for it explicitly or it's implicit, like with the :encoding(UTF-16LE) layer. Sneaky.

Both sysread() and recv() currently use <em>only</em> the ":utf8" flag for the stream, ignoring the actual layers. And since sysread() and recv() do no UTF-8 validation, they can end up creating invalidly encoded scalars. 😬

Same energy with syswrite() and send(): they use only the ":utf8" flag and otherwise ignore any layers. If the flag is set, both write the value UTF-8 encoded, even if the layer is some totally different encoding, like that UTF-16LE example above. Not it.

Ideally all of these operators would completely ignore the ":utf8" state and work only with bytes, but that would result in silently breaking existing code. To avoid that, a future version of perl will throw an exception when any of sysread(), recv(), syswrite() or send() are called on handles with the ":utf8" layer.

As of Perl 5.30, it is no longer possible to use sysread(), recv(), syswrite() or send() to read or send bytes from/to ":utf8" handles.

🧚 Use of unassigned code point or non-standalone grapheme for a delimiter 🧚

A grapheme is what looks like a character to a native speaker of a language. In Unicode (and therefore in Perl), a grapheme may actually be several adjacent characters that together form one complete grapheme. For example, there can be a base character like "R" and an accent like a circumflex "^", that appear to be a single character when displayed, with the circumflex hovering over the "R". So cute, so complicated. 🦋

As of Perl 5.30, use of delimiters which are non-standalone graphemes is fatal — all so the language can move toward accepting multi-character graphemes as delimiters.

Also, as of Perl 5.30, delimiters which are unassigned code points but that may someday become assigned are prohibited. Why? Because otherwise, code that works today would fail to compile if the currently unassigned delimiter ends up being something that isn't a stand-alone grapheme. And since Unicode is never going to assign non-character code points, nor code points above the legal Unicode maximum, those <em>can</em> be delimiters. Slay. ✨

🌈 Perl 5.28 🌈

🎀 Attributes ":locked" and ":unique" 🎀

The attributes ":locked" (on code references) and ":unique" (on array, hash and scalar references) have had no effect since Perl 5.005 and Perl 5.8.8 respectively. Their use has been deprecated since.

As of Perl 5.28, these attributes are syntax errors. Since the attributes literally do nothing, removing them from your code fixes the syntax error — and removing them will not influence the behaviour of your code. Free cleanup, bestie. 🧹

📜 Bare here-document terminators 📜

Perl used to let you use a bare here-document terminator "<<" to have the here-document end at the first empty line. This practise was deprecated in Perl 5.000; as of Perl 5.28, using a bare here-document terminator throws a fatal error.

You're encouraged to use the explicitly quoted form if you want an empty line to be the terminator of the here-document:

print <<"";
  Print this line.

# Previous blank line ends the here-document.

😭 Setting $/ to a reference to a non-positive integer 😭

So you assigned a reference to a scalar to $/ where the referenced item is <em>not</em> a positive integer. In older perls this appeared to work the same as setting it to "undef", but it was actually internally different, less efficient, and with <em>very</em> bad luck could have resulted in your file being split by a stringified form of the reference. 🙈

In Perl 5.20.0 this was changed so it would be exactly the same as setting $/ to "undef", with the one exception that this warning would be thrown.

As of Perl 5.28, setting $/ to a reference to a non-positive integer throws a fatal error.

You're recommended to change your code to set $/ to "undef" explicitly if you want to slurp the file. Do that. 💅

👑 Limit on the value of Unicode code points 👑

Unicode only allows code points up to 0x10FFFF, but Perl allows much larger ones. Up till Perl 5.28, it was allowed to use code points exceeding the maximum value of an integer ("IV_MAX"). However, that did break the perl interpreter in some constructs, including causing it to hang in a few cases. The known problem areas were in "tr///", regular expression pattern matching using quantifiers, as quote delimiters in "qX...X" (where X is the chr() of a large code point), and as the upper limits in loops. Not the vibe. 💀

The use of out-of-range code points was deprecated in Perl 5.24; as of Perl 5.28, using a code point exceeding "IV_MAX" throws a fatal error.

If your code is to run on various platforms, keep in mind that the upper limit depends on the platform. It is much larger on 64-bit word sizes than 32-bit ones. For 32-bit integers, "IV_MAX" equals 0x7FFFFFFF; for 64-bit integers, "IV_MAX" equals 0x7FFFFFFFFFFFFFFF.

🍓 Use of comma-less variable list in formats 🍓

It used to be allowed to use a list of variables in a format without separating them with commas. This usage has been deprecated for a <em>long</em> time, and as of Perl 5.28, this throws a fatal error.

🌸 Use of "\N{}" 🌸

Use of "\N{}" with nothing between the braces was deprecated in Perl 5.24, and throws a fatal error as of Perl 5.28.

Since such a construct is equivalent to using an empty string, you're recommended to just remove those "\N{}" constructs. Simple as that. ✨

🦋 Using the same symbol to open a filehandle and a dirhandle 🦋

It used to be legal to use open() to associate <em>both</em> a filehandle and a dirhandle to the same symbol (glob or scalar). This idiom is likely to be confusing, and it was deprecated in Perl 5.10.

Using the same symbol to open() a filehandle and a dirhandle throws a fatal error as of Perl 5.28.

You should be using two different symbols instead. Easy fix, bestie. 🫶

💜 ${^ENCODING} is no longer supported 💜

The special variable "${^ENCODING}" was used to implement the "encoding" pragma. Setting this variable to anything other than "undef" was deprecated in Perl 5.22. Full deprecation of the variable happened in Perl 5.25.3.

Setting this variable to anything other than an undefined value throws a fatal error as of Perl 5.28.

⭐ "B::OP::terse" ⭐

This method, which just calls "B::Concise::b_terse", has been deprecated, and disappeared in Perl 5.28. Please use B::Concise instead. 💅

💀 Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed 💀

As an (ahem) accidental feature, "AUTOLOAD" subroutines were looked up as methods (using the @ISA hierarchy) even when the subroutines to be autoloaded were called as plain functions (e.g. Foo::bar()), not as methods (e.g. "Foo->bar()" or $obj->bar()).

This bug was deprecated in Perl 5.004 and has been rectified in Perl 5.28 by using method lookup only for methods' "AUTOLOAD"s.

The simple rule is: Inheritance will not work when autoloading non-methods. The simple fix for old code is: In any module that used to depend on inheriting "AUTOLOAD" for non-methods from a base class named "BaseClass", execute *AUTOLOAD = \&BaseClass::AUTOLOAD during startup.

In code that currently says use AutoLoader; @ISA = qw(AutoLoader); you should remove AutoLoader from @ISA and change use AutoLoader; to use AutoLoader 'AUTOLOAD';.

🧚 In XS code, use of to_utf8_case() 🧚

This function has been removed as of Perl 5.28; instead convert to call the appropriate one of: "toFOLD_utf8_safe", "toLOWER_utf8_safe", "toTITLE_utf8_safe", or "toUPPER_utf8_safe".

🌈 Perl 5.26 🌈

🎀 "--libpods" in "Pod::Html" 🎀

Since Perl 5.18, the option "--libpods" has been deprecated, and using this option did not do anything other than producing a warning. Mid.

The "--libpods" option is no longer recognized as of Perl 5.26.

🗑️ The utilities "c2ph" and "pstruct" 🗑️

These old, perl3-era utilities have been deprecated in favour of "h2xs" for a long time. As of Perl 5.26, they have been removed. Gone gone. 💀

😭 Trapping $SIG{__DIE__} other than during program exit 😭

The $SIG{__DIE__} hook is called <em>even inside an eval()</em>. It was never intended to happen this way, but an implementation glitch made it possible. This used to be deprecated, as it allowed strange action at a distance like rewriting a pending exception in $@. Plans to rectify this have been <em>scrapped</em>, as users found that rewriting a pending exception is actually a useful feature, and not a bug. Growth. 🌱

Perl never issued a deprecation warning for this; the deprecation was by <em>documentation policy only</em>. But this deprecation has been lifted as of Perl 5.26. 🎉

Malformed UTF-8 string in "%s"

…hold that thought, bestie 💭

Ok so this next bit is about a message that means somebody messed up — either the Perl core itself or some XS code. 😭 Like, the code was trying to figure out whether a character — that it claimed was stored internally as UTF-8 — was a certain type, like punctuation or a digit. But plot twist: the character was not encoded in legal UTF-8. Rude. 💀

The %s in that message gets swapped out for a string that smart people who know stuff can use to figure out which type was being checked against. iykyk.

Passing malformed strings? Deprecated back in Perl 5.18, and then it became fatal in Perl 5.26. So yeah, it's giving "we're not doing that anymore." 🚫

🎀 Perl 5.24 🎀

Use of *glob{FILEHANDLE}

Using *glob{FILEHANDLE} got deprecated way back in Perl 5.8. The whole idea was that you were supposed to use *glob{IO} instead, because *glob{FILEHANDLE} is literally just an alias for it. 🙃

But bestie, plot twist: this feature got undeprecated in Perl 5.24. So it's back, it's fine, we move. ✨

Calling POSIX::%s() is deprecated

Okay so these functions in the POSIX module? No longer available. Gone. The list:

  • isalnum
  • isalpha
  • iscntrl
  • isdigit
  • isgraph
  • islower
  • isprint
  • ispunct
  • isspace
  • isupper
  • isxdigit

Why are they gone? Because they were buggy and they don't work on UTF-8 encoded strings. 💀 Not the vibe. Check their entries in POSIX if you want the full tea.

They were deprecated in Perl 5.20 and removed in Perl 5.24. Periodt.

🦋 Perl 5.16 🦋

Use of %s on a handle without * is deprecated

So back in the day, you could use tie, tied, or untie on a scalar while that scalar was holding a typeglob. And what did that do? It tied its filehandle. 🫠

Which caused two whole problems, lowkey:

  • There was no way left to tie the scalar itself while it held a typeglob.
  • There was no way to untie a scalar that had had a typeglob assigned to it.

This was deprecated in Perl 5.14, and the bug got fixed in Perl 5.16. Slay. 💅

So now? tie $scalar will always tie the scalar — not the handle it happens to be holding. To tie the handle, you gotta write tie *$scalar (with an explicit asterisk, bestie, don't forget it ⭐). And the exact same energy applies to tied *$scalar and untie *$scalar.

🌸 Quick recap so you don't fumble: no asterisk = the scalar. Asterisk = the handle. That's the whole thing. You got this. 🫶

🌈 SEE ALSO 🌈

  • warnings
  • diagnostics

And that's a wrap on PERLDEPRECATION(1), bestie!! 🎉 This one's from perl v5.42.3, dated 2026-08-03 — so if you're reading this, go check your deprecations, hydrate, and stay off malformed strings. 👑💖 Mwah! 🎀

📦 where this page comes from