This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
c96be0c671a0eb1fa14af64c71a3b6b7384d62f5
[perl5.git] / pod / perldeprecation.pod
1 =head1 NAME
2
3 perldeprecation - list Perl deprecations
4
5 =head1 DESCRIPTION
6
7 The purpose of this document is to document what has been deprecated
8 in Perl, and by which version the deprecated feature will disappear,
9 or, for already removed features, when it was removed.
10
11 This document will try to discuss what alternatives for the deprecated
12 features are available.
13
14 The deprecated features will be grouped by the version of Perl in
15 which they will be removed.
16
17 =head2 Perl 5.32
18
19 =head3 Constants from lexical variables potentially modified elsewhere
20
21 You wrote something like
22
23     my $var;
24     $sub = sub () { $var };
25
26 but $var is referenced elsewhere and could be modified after the C<sub>
27 expression is evaluated.  Either it is explicitly modified elsewhere
28 (C<$var = 3>) or it is passed to a subroutine or to an operator like
29 C<printf> or C<map>, which may or may not modify the variable.
30
31 Traditionally, Perl has captured the value of the variable at that
32 point and turned the subroutine into a constant eligible for inlining.
33 In those cases where the variable can be modified elsewhere, this
34 breaks the behavior of closures, in which the subroutine captures
35 the variable itself, rather than its value, so future changes to the
36 variable are reflected in the subroutine's return value.
37
38 If you intended for the subroutine to be eligible for inlining, then
39 make sure the variable is not referenced elsewhere, possibly by
40 copying it:
41
42     my $var2 = $var;
43     $sub = sub () { $var2 };
44
45 If you do want this subroutine to be a closure that reflects future
46 changes to the variable that it closes over, add an explicit C<return>:
47
48     my $var;
49     $sub = sub () { return $var };
50
51 This usage has been deprecated, and will no longer be allowed in Perl 5.32.
52
53 =head3 Use of strings with code points over 0xFF as arguments to C<vec>
54
55 C<vec> views its string argument as a sequence of bits.  A string
56 containing a code point over 0xFF is nonsensical.  This usage is
57 deprecated in Perl 5.28, and was removed in Perl 5.32.
58
59 =head3 Use of code points over 0xFF in string bitwise operators
60
61 The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat their
62 operands as strings of bytes. As such, values above 0xFF are
63 nonsensical. Some instances of these have been deprecated since Perl
64 5.24, and were made fatal in 5.28, but it turns out that in cases where
65 the wide characters did not affect the end result, no deprecation
66 notice was raised, and so remain legal.  Now, all occurrences either are
67 fatal or raise a deprecation warning, so that the remaining legal
68 occurrences became fatal in 5.32.
69
70 An example of this is
71
72  "" & "\x{100}"
73
74 The wide character is not used in the C<&> operation because the left
75 operand is shorter.  This now throws an exception.
76
77 =head3 hostname() doesn't accept any arguments
78
79 The function C<hostname()> in the L<Sys::Hostname> module has always
80 been documented to be called with no arguments.  Historically it has not
81 enforced this, and has actually accepted and ignored any arguments.  As a
82 result, some users have got the mistaken impression that an argument does
83 something useful.  To avoid these bugs, the function is being made strict.
84 Passing arguments was deprecated in Perl 5.28, and will become fatal in
85 Perl 5.32.
86
87 =head3 Unescaped left braces in regular expressions
88
89 The simple rule to remember, if you want to match a literal C<{>
90 character (U+007B C<LEFT CURLY BRACKET>) in a regular expression
91 pattern, is to escape each literal instance of it in some way.
92 Generally easiest is to precede it with a backslash, like C<\{>
93 or enclose it in square brackets (C<[{]>).  If the pattern
94 delimiters are also braces, any matching right brace (C<}>) should
95 also be escaped to avoid confusing the parser, for example,
96
97  qr{abc\{def\}ghi}
98
99 Forcing literal C<{> characters to be escaped will enable the Perl
100 language to be extended in various ways in future releases.  To avoid
101 needlessly breaking existing code, the restriction is is not enforced in
102 contexts where there are unlikely to ever be extensions that could
103 conflict with the use there of C<{> as a literal.  A non-deprecation
104 warning that the left brace is being taken literally is raised in
105 contexts where there could be confusion about it.
106
107 Literal uses of C<{> were deprecated in Perl 5.20, and some uses of it
108 started to give deprecation warnings since. These cases were made fatal
109 in Perl 5.26. Due to an oversight, not all cases of a use of a literal
110 C<{> got a deprecation warning.  Some cases started warning in Perl 5.26,
111 and were made fatal in Perl 5.30.  Other cases started in Perl 5.28,
112 and will be made fatal in 5.32.
113
114 =head3 In XS code, use of various macros dealing with UTF-8.
115
116 These macros will require an extra parameter in Perl 5.32:
117 C<isALPHANUMERIC_utf8>,
118 C<isASCII_utf8>,
119 C<isBLANK_utf8>,
120 C<isCNTRL_utf8>,
121 C<isDIGIT_utf8>,
122 C<isIDFIRST_utf8>,
123 C<isPSXSPC_utf8>,
124 C<isSPACE_utf8>,
125 C<isVERTWS_utf8>,
126 C<isWORDCHAR_utf8>,
127 C<isXDIGIT_utf8>,
128 C<isALPHANUMERIC_LC_utf8>,
129 C<isALPHA_LC_utf8>,
130 C<isASCII_LC_utf8>,
131 C<isBLANK_LC_utf8>,
132 C<isCNTRL_LC_utf8>,
133 C<isDIGIT_LC_utf8>,
134 C<isGRAPH_LC_utf8>,
135 C<isIDCONT_LC_utf8>,
136 C<isIDFIRST_LC_utf8>,
137 C<isLOWER_LC_utf8>,
138 C<isPRINT_LC_utf8>,
139 C<isPSXSPC_LC_utf8>,
140 C<isPUNCT_LC_utf8>,
141 C<isSPACE_LC_utf8>,
142 C<isUPPER_LC_utf8>,
143 C<isWORDCHAR_LC_utf8>,
144 C<isXDIGIT_LC_utf8>,
145 C<toFOLD_utf8>,
146 C<toLOWER_utf8>,
147 C<toTITLE_utf8>,
148 and
149 C<toUPPER_utf8>.
150
151 There is now a macro that corresponds to each one of these, simply by
152 appending C<_safe> to the name.  It takes the extra parameter.
153 For example, C<isDIGIT_utf8_safe> corresponds to C<isDIGIT_utf8>, but
154 takes the extra parameter, and its use doesn't generate a deprecation
155 warning.  All are documented in L<perlapi/Character case changing> and
156 L<perlapi/Character classification>.
157
158 You can change to use these versions at any time, or, if you can live
159 with the deprecation messages, wait until 5.32 and add the parameter to
160 the existing calls, without changing the names.
161
162 This change was originally scheduled for 5.30, but was delayed.
163
164 =head2 Perl 5.30
165
166 =head3 C<< $* >> is no longer supported
167
168 Before Perl 5.10, setting C<< $* >> to a true value globally enabled
169 multi-line matching within a string. This relique from the past lost
170 its special meaning in 5.10. Use of this variable will be a fatal error
171 in Perl 5.30, freeing the variable up for a future special meaning.
172
173 To enable multiline matching one should use the C<< /m >> regexp
174 modifier (possibly in combination with C<< /s >>). This can be set
175 on a per match bases, or can be enabled per lexical scope (including
176 a whole file) with C<< use re '/m' >>.
177
178 =head3 C<< $# >> is no longer supported
179
180 This variable used to have a special meaning -- it could be used
181 to control how numbers were formatted when printed. This seldom
182 used functionality was removed in Perl 5.10. In order to free up
183 the variable for a future special meaning, its use will be a fatal
184 error in Perl 5.30.
185
186 To specify how numbers are formatted when printed, one is advised
187 to use C<< printf >> or C<< sprintf >> instead.
188
189 =head3 Assigning non-zero to C<< $[ >> is fatal
190
191 This variable (and the corresponding C<array_base> feature and
192 L<arybase> module) allowed changing the base for array and string
193 indexing operations.
194
195 Setting this to a non-zero value has been deprecated since Perl 5.12 and
196 throws a fatal error as of Perl 5.30.
197
198 =head3 C<< File::Glob::glob() >> will disappear
199
200 C<< File::Glob >> has a function called C<< glob >>, which just calls
201 C<< bsd_glob >>. However, its prototype is different from the prototype
202 of C<< CORE::glob >>, and hence, C<< File::Glob::glob >> should not
203 be used.
204
205 C<< File::Glob::glob() >> was deprecated in Perl 5.8. A deprecation
206 message was issued from Perl 5.26 onwards, and the function will
207 disappear in Perl 5.30.
208
209 Code using C<< File::Glob::glob() >> should call
210 C<< File::Glob::bsd_glob() >> instead.
211
212 =head3 Unescaped left braces in regular expressions (for 5.30)
213
214 See L</Unescaped left braces in regular expressions> above.
215
216 =head3 Unqualified C<dump()>
217
218 Use of C<dump()> instead of C<CORE::dump()> was deprecated in Perl 5.8,
219 and an unqualified C<dump()> will no longer be available in Perl 5.30.
220
221 See L<perlfunc/dump>.
222
223
224 =head3 Using my() in false conditional.
225
226 There has been a long-standing bug in Perl that causes a lexical variable
227 not to be cleared at scope exit when its declaration includes a false
228 conditional.  Some people have exploited this bug to achieve a kind of
229 static variable.  Since we intend to fix this bug, we don't want people
230 relying on this behavior.
231
232 Instead, it's recommended one uses C<state> variables to achieve the
233 same effect:
234
235     use 5.10.0;
236     sub count {state $counter; return ++ $counter}
237     say count ();    # Prints 1
238     say count ();    # Prints 2
239
240 C<state> variables were introduced in Perl 5.10.
241
242 Alternatively, you can achieve a similar static effect by
243 declaring the variable in a separate block outside the function, eg
244
245     sub f { my $x if 0; return $x++ }
246
247 becomes
248
249     { my $x; sub f { return $x++ } }
250
251 The use of C<my()> in a false conditional has been deprecated in
252 Perl 5.10, and it will become a fatal error in Perl 5.30.
253
254
255 =head3 Reading/writing bytes from/to :utf8 handles.
256
257 The sysread(), recv(), syswrite() and send() operators are
258 deprecated on handles that have the C<:utf8> layer, either explicitly, or
259 implicitly, eg., with the C<:encoding(UTF-16LE)> layer.
260
261 Both sysread() and recv() currently use only the C<:utf8> flag for the stream,
262 ignoring the actual layers.  Since sysread() and recv() do no UTF-8
263 validation they can end up creating invalidly encoded scalars.
264
265 Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise ignoring
266 any layers.  If the flag is set, both write the value UTF-8 encoded, even if
267 the layer is some different encoding, such as the example above.
268
269 Ideally, all of these operators would completely ignore the C<:utf8> state,
270 working only with bytes, but this would result in silently breaking existing
271 code.  To avoid this a future version of perl will throw an exception when
272 any of sysread(), recv(), syswrite() or send() are called on handle with the
273 C<:utf8> layer.
274
275 In Perl 5.30, it will no longer be possible to use sysread(), recv(),
276 syswrite() or send() to read or send bytes from/to :utf8 handles.
277
278
279 =head3 Use of unassigned code point or non-standalone grapheme for a delimiter.
280
281 A grapheme is what appears to a native-speaker of a language to be a
282 character.  In Unicode (and hence Perl) a grapheme may actually be
283 several adjacent characters that together form a complete grapheme.  For
284 example, there can be a base character, like "R" and an accent, like a
285 circumflex "^", that appear to be a single character when displayed,
286 with the circumflex hovering over the "R".
287
288 As of Perl 5.30, use of delimiters which are non-standalone graphemes is
289 fatal, in order to move the language to be able to accept
290 multi-character graphemes as delimiters.
291
292 Also, as of Perl 5.30, delimiters which are unassigned code points
293 but that may someday become assigned are prohibited.  Otherwise, code
294 that works today would fail to compile if the currently unassigned
295 delimiter ends up being something that isn't a stand-alone grapheme.
296 Because Unicode is never going to assign L<non-character code
297 points|perlunicode/Noncharacter code points>, nor L<code points that are
298 above the legal Unicode maximum|perlunicode/Beyond Unicode code
299 points>, those can be delimiters.
300
301
302 =head2 Perl 5.28
303
304 =head3 Attributes C<< :locked >> and C<< :unique >>
305
306 The attributes C<< :locked >> (on code references) and C<< :unique >>
307 (on array, hash and scalar references) have had no effect since 
308 Perl 5.005 and Perl 5.8.8 respectively. Their use has been deprecated
309 since.
310
311 As of Perl 5.28, these attributes are syntax errors. Since the
312 attributes do not do anything, removing them from your code fixes
313 the syntax error; and removing them will not influence the behaviour
314 of your code.
315
316
317 =head3 Bare here-document terminators
318
319 Perl has allowed you to use a bare here-document terminator to have the
320 here-document end at the first empty line. This practise was deprecated
321 in Perl 5.000; as of Perl 5.28, using a bare here-document terminator
322 throws a fatal error.
323
324 You are encouraged to use the explicitly quoted form if you wish to
325 use an empty line as the terminator of the here-document:
326
327   print <<"";
328     Print this line.
329
330   # Previous blank line ends the here-document.
331
332
333 =head3 Setting $/ to a reference to a non-positive integer
334
335 You assigned a reference to a scalar to C<$/> where the
336 referenced item is not a positive integer.  In older perls this B<appeared>
337 to work the same as setting it to C<undef> but was in fact internally
338 different, less efficient and with very bad luck could have resulted in
339 your file being split by a stringified form of the reference.
340
341 In Perl 5.20.0 this was changed so that it would be B<exactly> the same as
342 setting C<$/> to undef, with the exception that this warning would be
343 thrown.
344
345 As of Perl 5.28, setting C<$/> to a reference of a non-positive
346 integer throws a fatal error.
347
348 You are recommended to change your code to set C<$/> to C<undef> explicitly
349 if you wish to slurp the file.
350
351
352 =head3 Limit on the value of Unicode code points.
353
354 Unicode only allows code points up to 0x10FFFF, but Perl allows
355 much larger ones. Up till Perl 5.28, it was allowed to use code
356 points exceeding the maximum value of an integer (C<IV_MAX>).
357 However, that did break the perl interpreter in some constructs,
358 including causing it to hang in a few cases.  The known problem
359 areas were in C<tr///>, regular expression pattern matching using
360 quantifiers, as quote delimiters in C<qI<X>...I<X>> (where I<X> is
361 the C<chr()> of a large code point), and as the upper limits in
362 loops.
363
364 The use of out of range code points was deprecated in Perl 5.24; as of
365 Perl 5.28 using a code point exceeding C<IV_MAX> throws a fatal error.
366
367 If your code is to run on various platforms, keep in mind that the upper
368 limit depends on the platform. It is much larger on 64-bit word sizes
369 than 32-bit ones. For 32-bit integers, C<IV_MAX> equals C<0x7FFFFFFF>,
370 for 64-bit integers, C<IV_MAX> equals C<0x7FFFFFFFFFFFFFFF>.
371
372
373 =head3 Use of comma-less variable list in formats.
374
375 It was allowed to use a list of variables in a format, without
376 separating them with commas. This usage has been deprecated
377 for a long time, and as of Perl 5.28, this throws a fatal error.
378
379 =head3 Use of C<\N{}>
380
381 Use of C<\N{}> with nothing between the braces was deprecated in
382 Perl 5.24, and throws a fatal error as of Perl 5.28.
383
384 Since such a construct is equivalent to using an empty string,
385 you are recommended to remove such C<\N{}> constructs.
386
387 =head3 Using the same symbol to open a filehandle and a dirhandle
388
389 It used to be legal to use C<open()> to associate both a
390 filehandle and a dirhandle to the same symbol (glob or scalar).
391 This idiom is likely to be confusing, and it was deprecated in
392 Perl 5.10.
393
394 Using the same symbol to C<open()> a filehandle and a dirhandle
395 throws a fatal error as of Perl 5.28.
396
397 You should be using two different symbols instead.
398
399 =head3 ${^ENCODING} is no longer supported.
400
401 The special variable C<${^ENCODING}> was used to implement
402 the C<encoding> pragma. Setting this variable to anything other
403 than C<undef> was deprecated in Perl 5.22. Full deprecation
404 of the variable happened in Perl 5.25.3.
405
406 Setting this variable to anything other than an undefined value
407 throws a fatal error as of Perl 5.28.
408
409
410 =head3 C<< B::OP::terse >>
411
412 This method, which just calls C<< B::Concise::b_terse >>, has been
413 deprecated, and disappeared in Perl 5.28. Please use 
414 C<< B::Concise >> instead.
415
416
417
418 =head3 Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed
419
420 As an (ahem) accidental feature, C<AUTOLOAD> subroutines were looked
421 up as methods (using the C<@ISA> hierarchy) even when the subroutines
422 to be autoloaded were called as plain functions (e.g. C<Foo::bar()>),
423 not as methods (e.g. C<< Foo->bar() >> or C<< $obj->bar() >>).
424
425 This bug was deprecated in Perl 5.004, has been rectified in Perl 5.28
426 by using method lookup only for methods' C<AUTOLOAD>s.
427
428 The simple rule is:  Inheritance will not work when autoloading
429 non-methods.  The simple fix for old code is:  In any module that used
430 to depend on inheriting C<AUTOLOAD> for non-methods from a base class
431 named C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during
432 startup.
433
434 In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);>
435 you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
436 C<use AutoLoader 'AUTOLOAD';>.
437
438
439 =head3 Use of code points over 0xFF in string bitwise operators
440
441 The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat
442 their operands as strings of bytes. As such, values above 0xFF 
443 are nonsensical. Using such code points with these operators
444 was deprecated in Perl 5.24, and is fatal as of Perl 5.28.
445
446 =head3 In XS code, use of C<to_utf8_case()>
447
448 This function has been removed as of Perl 5.28; instead convert to call
449 the appropriate one of:
450 L<C<toFOLD_utf8_safe>|perlapi/toFOLD_utf8_safe>.
451 L<C<toLOWER_utf8_safe>|perlapi/toLOWER_utf8_safe>,
452 L<C<toTITLE_utf8_safe>|perlapi/toTITLE_utf8_safe>,
453 or
454 L<C<toUPPER_utf8_safe>|perlapi/toUPPER_utf8_safe>.
455
456 =head2 Perl 5.26
457
458 =head3 C<< --libpods >> in C<< Pod::Html >>
459
460 Since Perl 5.18, the option C<< --libpods >> has been deprecated, and
461 using this option did not do anything other than producing a warning.
462
463 The C<< --libpods >> option is no longer recognized as of Perl 5.26.
464
465
466 =head3 The utilities C<< c2ph >> and C<< pstruct >>
467
468 These old, perl3-era utilities have been deprecated in favour of
469 C<< h2xs >> for a long time. As of Perl 5.26, they have been removed.
470
471
472 =head3 Trapping C<< $SIG {__DIE__} >> other than during program exit.
473
474 The C<$SIG{__DIE__}> hook is called even inside an C<eval()>. It was
475 never intended to happen this way, but an implementation glitch made
476 this possible. This used to be deprecated, as it allowed strange action
477 at a distance like rewriting a pending exception in C<$@>. Plans to
478 rectify this have been scrapped, as users found that rewriting a
479 pending exception is actually a useful feature, and not a bug.
480
481 Perl never issued a deprecation warning for this; the deprecation
482 was by documentation policy only. But this deprecation has been 
483 lifted as of Perl 5.26.
484
485
486 =head3 Malformed UTF-8 string in "%s"
487
488 This message indicates a bug either in the Perl core or in XS
489 code. Such code was trying to find out if a character, allegedly
490 stored internally encoded as UTF-8, was of a given type, such as
491 being punctuation or a digit.  But the character was not encoded
492 in legal UTF-8.  The C<%s> is replaced by a string that can be used
493 by knowledgeable people to determine what the type being checked
494 against was.
495
496 Passing malformed strings was deprecated in Perl 5.18, and
497 became fatal in Perl 5.26.
498
499
500 =head2 Perl 5.24
501
502 =head3 Use of C<< *glob{FILEHANDLE} >>
503
504 The use of C<< *glob{FILEHANDLE} >> was deprecated in Perl 5.8.
505 The intention was to use C<< *glob{IO} >> instead, for which 
506 C<< *glob{FILEHANDLE} >> is an alias.
507
508 However, this feature was undeprecated in Perl 5.24.
509
510 =head3 Calling POSIX::%s() is deprecated
511
512 The following functions in the C<POSIX> module are no longer available:
513 C<isalnum>, C<isalpha>, C<iscntrl>, C<isdigit>, C<isgraph>, C<islower>,  
514 C<isprint>, C<ispunct>, C<isspace>, C<isupper>, and C<isxdigit>.  The 
515 functions are buggy and don't work on UTF-8 encoded strings.  See their
516 entries in L<POSIX> for more information.
517
518 The functions were deprecated in Perl 5.20, and removed in Perl 5.24.
519
520
521 =head2 Perl 5.16
522
523 =head3 Use of %s on a handle without * is deprecated
524
525 It used to be possible to use C<tie>, C<tied> or C<untie> on a scalar
526 while the scalar holds a typeglob. This caused its filehandle to be
527 tied. It left no way to tie the scalar itself when it held a typeglob,
528 and no way to untie a scalar that had had a typeglob assigned to it.
529
530 This was deprecated in Perl 5.14, and the bug was fixed in Perl 5.16.
531
532 So now C<tie $scalar> will always tie the scalar, not the handle it holds.
533 To tie the handle, use C<tie *$scalar> (with an explicit asterisk).  The same
534 applies to C<tied *$scalar> and C<untie *$scalar>.
535
536
537 =head1 SEE ALSO
538
539 L<warnings>, L<diagnostics>.
540
541 =cut