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