1N/Aperltodo - Perl TO-DO List
1N/AThis is a list of wishes for Perl. Send updates to
1N/AI<perl5-porters@perl.org>. If you want to work on any of these
1N/Aprojects, be sure to check the perl5-porters archives for past ideas,
1N/Aflames, and propaganda. This will save you time and also prevent you
1N/Afrom implementing something that Larry has already vetoed. One set
1N/Aof archives may be found at:
1N/A=head2 Support for I/O disciplines
1N/AC<perlio> provides this, but the interface could be a lot more
1N/AWhen the lexer sees, for instance, C<bytes::length>, it should
1N/Aautomatically load the C<bytes> pragma.
1N/A=head2 Make "\u{XXXX}" et al work
1N/ADanger, Will Robinson! Discussing the semantics of C<"\x{F00}">,
1N/AC<"\xF00"> and C<"\U{F00}"> on P5P I<will> lead to a long and boring
1N/A=head2 Create a char *sv_pvprintify(sv, STRLEN *lenp, UV flags)
1N/AFor displaying PVs with control characters, embedded nulls, and Unicode.
1N/AThis would be useful for printing warnings, or data and regex dumping,
1N/Anot_a_number(), and so on.
1N/ARequirements: should handle both byte and UTF-8 strings. isPRINT()
1N/Acharacters printed as-is, character less than 256 as \xHH, Unicode
1N/Acharacters as \x{HHH}. Don't assume ASCII-like, either, get somebody
1N/Aon EBCDIC to test the output.
1N/APossible options, controlled by the flags:
1N/A- whitespace (other than ' ' of isPRINT()) printed as-is
1N/A- use isPRINT_LC() instead of isPRINT()
1N/A- print control characters like this: "\cA"
1N/A- print control characters like this: "^A"
1N/A- non-PRINTables printed as '.' instead of \xHH
1N/A- use \OOO instead of \xHH
1N/A- have a maximum length for the produced string (read it from *lenp)
1N/A- append a "..." to the produced string if the maximum length is exceeded
1N/A- really fancy: print unicode characters as \N{...}
1N/ANOTE: pv_display(), pv_uni_display(), sv_uni_display() are already
1N/Adoing something like the above.
1N/A=head2 Overloadable regex assertions
1N/AThis may or may not be possible with the current regular expression
1N/Aengine. The idea is that, for instance, C<\b> needs to be
1N/Aalgorithmically computed if you're dealing with Thai text. Hence, the
1N/AB<\b> assertion wants to be overloaded by a function.
1N/AAllow for long form of the General Category Properties,
e.g 1N/AC<\p{IsOpenPunctuation}>, not just the abbreviated form,
e.g. 1N/AAllow for the metaproperties: C<XID Start>, C<XID Continue>,
1N/AC<NF*_NO>, C<NF*_MAYBE> (require the DerivedCoreProperties and
1N/ADerviceNormalizationProperties files).
1N/AThere are also multiple value properties still unimplemented:
1N/AC<Numeric Type>, C<East Asian Width>.
1N/AMostly implemented (all of 1:1, 1:N, N:1), only the "final sigma"
1N/Aand locale-specific rules of SpecCase are not implemented.
1N/AUTF-8 identifier names should probably be canonicalized: NFC?
1N/AUTF-8 in package names and sub names? The first is problematic
1N/Abecause of the mapping to pathnames, ditto for the second one if
1N/Aone does autosplitting, for example. Some of this works already
1N/Ain 5.8.0, but essentially it is unsupported. Constructs to consider,
1N/A package UnicodePackage;
1N/A sub new { bless {}, shift };
1N/A sub UnicodeMethod1 { ... $_[0]->UnicodeMethod2(...) ... }
1N/A sub UnicodeMethod2 { ... } # in here caller(0) should contain Unicode
1N/A my $x = UnicodePackage->new;
1N/A print ref $x, "\n"; # should be Unicode
1N/A $x->UnicodeMethod1(...);
1N/A my $y = UnicodeMethod3 UnicodePackage ...;
1N/AIn the above all I<UnicodeXxx> contain (identifier-worthy) characters
1N/Asubroutine names can be returned needs to be checked for Unicodeness.
1N/Athere and what's missing. Almost all of Levels 2 and 3 is missing,
1N/Aand as of 5.8.0 not even all of Level 1 is there.
1N/AThey have some tricks Perl doesn't yet implement, such as character
1N/AThere are some suggestions to use for example something like this:
1N/Adefault to "(thread exiting first will) wait for the other threads
1N/Auntil up to 60 seconds". Other possibilities:
1N/A use threads wait => 0;
1N/A use threads wait_for => 10;
1N/AWait up to 10 seconds.
1N/A use threads wait_for => -1;
1N/A=head2 Better support for nonpreemptive threading systems like GNU pth
1N/ATo better support nonpreemptive threading systems, perhaps some of the
1N/Ablocking functions internally in Perl should do a yield() before a
1N/Ablocking call. (Now certain threads tests ({basic,list,
thread.t})
1N/Asimply do a yield() before they sleep() to give nonpreemptive thread
1N/Aimplementations a chance).
1N/AIn some cases, like the GNU pth, which has replacement functions that
1N/Aare nonblocking (pth_select instead of select), maybe Perl should be
1N/Ausing them instead when built for threading.
1N/A=head2 Typed lexicals for compiler
1N/A=head2 Compiler workarounds for Win32
1N/A=head2 AUTOLOADing in the compiler
1N/A=head2 Fixing comppadlist when compiling
1N/A=head2 Cleaning up exported namespace
1N/A=head2 Complete signal handling
1N/AAdd C<PERL_ASYNC_CHECK> to opcodes which loop; replace C<sigsetjmp> with
1N/AC<sigjmp>; check C<wait> for signal safety.
1N/A=head2 Out-of-source builds
1N/AThis was done for 5.6.0, but needs reworking for
5.7.x 1N/A=head2 POSIX realtime support
1N/APOSIX 1003.1 1996 Edition support--realtime stuff: POSIX semaphores,
1N/Amessage queues, shared memory, realtime clocks, timers, signals (the
1N/Ametaconfig units mostly already exist for these)
1N/A=head2 UNIX98 support
1N/AThere are non-core modules, such as C<Socket6>, but these will need
1N/Aintegrating when IPv6 actually starts to really happen. See RFC 2292
1N/A=head2 Long double conversion
1N/AFloating point formatting is still causing some weird test failures.
1N/ALocales and Unicode interact with each other in unpleasant ways.
1N/A=head2 Arithmetic on non-Arabic numerals
1N/AC<[1234567890]> aren't the only numerals any more.
1N/A=head2 POSIX Unicode character classes
1N/A(C<[=a=]> for equivalence classes, C<[.ch.]> for collation.)
1N/AThese are dependent on Unicode normalization and collation.
1N/ACurrently, the user has to optimize C<foo|far> and C<foo|goo> into
1N/AC<f(?:oo|ar)> and C<[fg]oo> by hand; this could be done automatically.
1N/A=head2 Security audit shipped utilities
1N/AAll the code we ship with Perl needs to be sensible about temporary file
1N/Ahandling, locking, input validation, and so on.
1N/A=head2 Sort out the uid-setting mess
1N/ACurrently there are several problems with the setting of uids ($<, $>
1N/Afor the real and effective uids). Firstly, what exactly setuid() call
1N/Agets invoked in which platform is simply a big mess that needs to be
1N/Auntangled. Secondly, the effects are apparently not standard across
1N/Aplatforms, (if you first set $< and then $>, or vice versa, being
1N/Auid == euid == zero, or just euid == zero, or as a normal user, what are
1N/Athe results?). The test suite not (usually) being run as root means
1N/Athat these things do not get much testing. Thirdly, there's quite
1N/Aoften a third uid called saved uid, and Perl has no knowledge of that
1N/Afeature in any way. (If one has the saved uid of zero, one can get
1N/Aback any real and effective uids.) As an example, to change also the
1N/Asaved uid, one needs to set the real and effective uids B<twice>-- in
1N/Amost systems, that is: in HP-UX that doesn't seem to work.
1N/A=head2 Custom opcodes
1N/AHave a way to introduce user-defined opcodes without the subroutine call
1N/Aoverhead of an XSUB; the user should be able to create PP code. Simon
1N/ACozens has some ideas on this.
1N/A=head2 DLL Versioning
1N/AWindows needs a way to know what version of an XS or C<libperl> DLL it's
1N/A=head2 Introduce @( and @)
1N/AC<$(> may return "foo bar baz". Unfortunately, since groups can
1N/Atheoretically have spaces in their names, this could be one, two or
1N/A=head2 Floating point handling
1N/AC<NaN> and C<inf> support is particularly troublesome.
1N/A(fp_classify(), fp_class(), fp_class_d(), class(), isinf(),
1N/Aisfinite(), finite(), isnormal(), unordered(), <
ieeefp.h>,
1N/A<
fp_class.h> (there are metaconfig units for all these) (I think),
1N/Afp_setmask(), fp_getmask(), fp_setround(), fp_getround()
1N/A(no metaconfig units yet for these). Don't forget finitel(), fp_classl(),
1N/Afp_class_l(), (yes, both do, unfortunately, exist), and unorderedl().)
1N/AAs of Perl 5.6.1, there is a Perl macro, Perl_isnan().
1N/ANicholas Clark has done a lot of work on this, but work is continuing.
1N/AC<+>, C<-> and C<*> work, but guards need to be in place for C<%>, C</>,
1N/AC<&>, C<oct>, C<hex> and C<pack>.
1N/A=head2 Replace pod2html with something using Pod::Parser
1N/AThe CPAN module C<Marek::Pod::Html> may be a more suitable basis for a
1N/AC<pod2html> converter; the current one duplicates the functionality
1N/Aabstracted in C<Pod::Parser>, which makes updating the POD language
1N/A=head2 Automate module testing on CPAN
1N/AWhen a new Perl is being beta tested, porters have to manually grab
1N/Atheir favourite CPAN modules and test them - this should be done
1N/A=head2 sendmsg and recvmsg
1N/AWe have all the other BSD socket functions but these. There are
1N/Ametaconfig units for these functions which can be added. To avoid these
1N/Abeing new opcodes, a solution similar to the way C<sockatmark> was added
1N/Awould be preferable. (Autoload the C<IO::whatever> module.)
1N/A=head2 Rewrite perlre documentation
1N/AThe new-style patterns need full documentation, and the whole document
1N/Aneeds to be a lot clearer.
1N/A=head2 Convert example code to IO::Handle filehandles
1N/A=head2 Document Win32 choices
1N/A=head2 Check new modules
1N/A=head2 Make roffitall find pods and libs itself
1N/ASimon Cozens has done some work on this but it needs a rethink.
1N/A=head1 To do at some point
1N/AThese are ideas that have been regularly tossed around, that most
1N/Apeople believe should be done maybe during
5.8.x 1N/A=head2 Remove regular expression recursion
1N/ABecause the regular expression engine is recursive, badly designed
1N/Aexpressions can lead to lots of recursion filling up the stack. Ilya
1N/Aclaims that it is easy to convert the engine to being iterative, but
1N/Athis has still not yet been done. There may be a regular expression
1N/Aengine hit squad meeting at TPC5.
1N/A=head2 Memory leaks after failed eval
1N/APerl will leak memory if you C<eval "hlagh hlagh hlagh hlagh">. This is
1N/Apartially because it attempts to build up an op tree for that code and
1N/Adoesn't properly free it. The same goes for non-syntactically-correct
1N/Aregular expressions. Hugo looked into this, but decided it needed a
1N/Amark-and-sweep GC implementation.
1N/AAlan notes that: The basic idea was to extend the parser token stack
1N/A(C<YYSTYPE>) to include a type field so we knew what sort of thing each
1N/Aelement of the stack was. The F<
perly.c> code would then have to be
1N/Apostprocessed to record the type of each entry on the stack as it was
1N/Acreated, and the parser patched so that it could unroll the stack
1N/AThis is possible to do, but would be pretty messy to implement, as it
1N/A=head2 bitfields in pack
1N/A=head2 Cross compilation
1N/AMake Perl buildable with a cross-compiler. This will play havoc with
1N/AConfigure, which needs to know how the target system will respond to
1N/Aits tests; maybe C<microperl> will be a good starting point here.
1N/A(Indeed, Bart Schuller reports that he compiled up C<microperl> for
1N/Athe Agenda PDA and it works fine.) A really big spanner in the works
1N/Ais the bootstrapping build process of Perl: if the filesystem the
1N/Atarget systems sees is not the same what the build host sees, various
1N/Ainput, output, and (Perl) library files need to be copied back and forth.
1N/AAs of 5.8.0 Configure mostly works for cross-compilation
1N/A(used successfully for iPAQ Linux), miniperl gets built,
1N/Abut then building DynaLoader (and other extensions) fails
1N/Asince MakeMaker knows nothing of cross-compilation.
1N/A=head2 Perl preprocessor / macros
1N/ASource filters help with this, but do not get us all the way. For
1N/Ainstance, it should be possible to implement the C<??> operator somehow;
1N/Asource filters don't (quite) cut it.
1N/A=head2 Perl lexer in Perl
1N/ADamian Conway is planning to work on this, but it hasn't happened yet.
1N/A=head2 Using POSIX calls internally
1N/AWhen faced with a BSD vs. SysV -style interface to some library or
1N/Asystem function, perl's roots show in that it typically prefers the BSD
1N/Ainterface (but falls back to the SysV one). One example is getpgrp().
1N/AOther examples include C<memcpy> vs. C<bcopy>. There are others, mostly in
1N/AMostly, this item is a suggestion for which way to start a journey into
1N/Aan C<#ifdef> forest. It is not primarily a suggestion to eliminate any of
1N/Athe C<#ifdef> forests.
1N/APOSIX calls are perhaps more likely to be portable to unexpected
1N/Aarchitectures. They are also perhaps more likely to be actively
1N/Amaintained by a current vendor. They are also perhaps more likely to be
1N/Aavailable in thread-safe versions, if appropriate.
1N/A=head2 -i rename file when changed
1N/AIt's only necessary to rename a file when inplace editing when the file
1N/Ahas changed. Detecting a change is perhaps the difficult bit.
1N/A=head2 All ARGV input should act like E<lt>E<gt>
1N/Aeg C<read(ARGV, ...)> doesn't currently read across multiple files.
1N/A=head2 Support for rerunning debugger
1N/AThere should be a way of restarting the debugger on demand.
1N/A=head2 Test Suite for the Debugger
1N/AThe debugger is a complex piece of software and fixing something
1N/Ahere may inadvertently break something else over there. To tame
1N/Athis chaotic behaviour, a test suite is necessary.
1N/A=head2 my sub foo { }
1N/AThe basic principle is sound, but there are problems with the semantics
1N/Aof self-referential and mutually referential lexical subs: how to
1N/A=head2 One-pass global destruction
1N/ASweeping away all the allocated memory in one go is a laudable goal, but
1N/Ait's difficult and in most cases, it's easier to let the memory get
1N/A=head2 Rewrite regexp parser
1N/AThere has been talk recently of rewriting the regular expression parser
1N/Ato produce an optree instead of a chain of opcodes; it's unclear whether
1N/Aor not this would be a win.
1N/A=head2 Cache recently used regexps
1N/A for my $re (@regexps) {
1N/AC<qr//> already gives us a way of saving compiled regexps, but it should
1N/Abe done automatically.
1N/A=head2 Cross-compilation support
1N/ABart Schuller reports that using C<microperl> and a cross-compiler, he
1N/Agot Perl working on the Agenda PDA. However, one cannot build a full
1N/APerl because Configure needs to get the results for the target platform,
1N/A=head2 Bit-shifting bitvectors
1N/A vec($v, 1000, 1) = 1;
1N/AOne should be able to do
1N/Aand have the 999'th bit set.
1N/ACurrently if you try with shift bitvectors you shift the
NV/UV, instead
1N/Aof the bits in the PV. Not very logical.
1N/A=head2 debugger pragma
1N/AThe debugger is implemented in Perl in F<
perl5db.pl>; turning it into a
1N/Apragma should be easy, but making it work lexically might be more
1N/Adifficult. Fiddling with C<$^P> would be necessary.
1N/A=head2 use less pragma
1N/Ato switch between them.
1N/A=head2 switch structures
1N/AAlthough we have C<
Switch.pm> in core, Larry points to the dormant
1N/AC<nswitch> and C<cswitch> ops in F<
pp.c>; using these opcodes would be
1N/A=head2 Cache eval tree
1N/A=head2 Shrink opcode tables
1N/A=head2 Optimize away @_
1N/ALook at the "reification" code in C<
av.c>
1N/A=head2 Prototypes versus indirect objects
1N/ACurrently, indirect object syntax bypasses prototype checks.
1N/AHTML versions of the documentation need to be installed by default; a
1N/Acall to C<installhtml> from C<installperl> may be all that's necessary.
1N/A=head2 Prototype method calls
1N/A=head2 Return context prototype declarations
1N/A=head2 Garbage collection
1N/AThere have been persistent mumblings about putting a mark-and-sweep
1N/Agarbage detector into Perl; Alan Burlison has some ideas about this.
1N/AMark-Jason Dominus has the beginnings of one of these.
1N/A=head2 Rewrite perldoc
1N/AThere are a few suggestions for what to do with C<perldoc>: maybe a
1N/Afull-text search, an index function, locating pages on a particular
1N/Ahigh-level subject, and so on.
1N/A=head2 Install .3p manpages
1N/AThis is a bone of contention; we can create C<.3p> manpages for each
1N/Abuilt-in function, but should we install them by default? Tcl does this,
1N/Aand it clutters up C<apropos>.
1N/A=head2 Unicode tutorial
1N/ASimon Cozens promises to do this before he gets old.
1N/A=head2 Retargetable installation
1N/AAllow C<@INC> to be changed after Perl is built.
1N/A=head2 POSIX emulation on non-POSIX systems
1N/AMake C<
POSIX.pm> behave as POSIXly as possible everywhere, meaning we
1N/Ahave to implement POSIX equivalents for some functions if necessary.
1N/A=head2 Rename Win32 headers
1N/A=head2 Finish off lvalue functions
1N/AThey don't work in the debugger, and they don't work for list or hash
1N/A=head2 Update sprintf documentation
1N/AHugo van der Sanden plans to look at this.
1N/AThis has been done in places, but needs a thorough code review.
1N/AAlso fchdir is available in some platforms.
1N/A=head2 Make v-strings overloaded objects
1N/AInstead of having to guess whether a string is a v-string and thus
1N/Aneeds to be displayed with %vd, make v-strings (readonly) objects
1N/A(class "vstring"?) with a stringify overload.
1N/A=head2 Allow restricted hash assignment
1N/ACurrently you're not allowed to assign to a restricted hash at all,
1N/Aeven with the same keys.
1N/A %restricted = (foo => 42); # error
1N/AThis should be allowed if the new keyset is a subset of the old
1N/Akeyset. May require more extra code than we'd like in pp_aassign.
1N/A=head2 Should overload be inheritable?
1N/AShould overload be 'contagious' through @ISA so that derived classes
1N/Awould inherit their base classes' overload definitions? What to do
1N/Ain case of overload conflicts?
1N/AShould taint be stopped from affecting control flow, if ($tainted)?
1N/AShould tainted symbolic method calls and subref calls be stopped?
1N/A(Look at Ruby's $SAFE levels for inspiration?)
1N/A=head2 Perform correctly when XSUBs call subroutines that exit via goto(LABEL) and friends
1N/AIf an XSUB calls a subroutine that exits using goto(LABEL),
1N/Alast(LABEL) or next(LABEL), then the interpreter will very probably crash
1N/Awith a segfault because the execution resumes in the XSUB instead of
1N/Anever returning there.
1N/AIdeas which have been discussed, and which may or may not happen.
1N/A=head2 ref() in list context
1N/AIt's unclear what this should do or how to do it without breaking old
1N/A=head2 Make tr/// return histogram of characters in list context
1N/AThere is a patch for this, but it may require Unicodification.
1N/A=head2 Compile to real threaded code
1N/A=head2 Structured types
1N/A=head2 Modifiable $1 et al.
1N/A ($x = "elephant") =~ /e(ph)/;
1N/A $1 = "g"; # $x = "elegant"
1N/AWhat happens if there are multiple (nested?) brackets? What if the
1N/Astring changes between the match and the assignment?
1N/A=head2 Procedural interfaces for IO::*, etc.
1N/ASome core modules have been accused of being overly-OO. Adding
1N/Aprocedural interfaces could demystify them.
1N/AWith C<gdb>, you can attach the debugger to a running program if you
1N/Apass the process ID. It would be good to do this with the Perl debugger
1N/Aon a running Perl program, although I'm not sure how it would be done.
1N/AA non-core module that would use "native" GUI to create graphical
1N/A=head2 foreach(reverse ...)
1N/A foreach (reverse @_) { ... }
1N/Aputs C<@_> on the stack, reverses it putting the reversed version on the
1N/Astack, then iterates forwards. Instead, it could be special-cased to put
1N/AC<@_> on the stack then iterate backwards.
1N/A=head2 Constant function cache
1N/A=head2 Approximate regular expression matching
1N/AThese items B<always> need doing:
1N/A=head2 Update guts documentation
1N/ASimon Cozens tries to do this when possible, and contributions to the
1N/AC<perlapi> documentation is welcome.
1N/A=head2 Add more tests
1N/AMichael Schwern will donate $500 to Yet Another Society when all core
1N/A=head2 Update auxiliary tools
1N/AThe code we ship with Perl should look like good Perl 5.
1N/A=head2 Create debugging macros
1N/ADebugging macros (like printsv, dump) can make debugging perl inside a
1N/AC debugger much easier. A good set for gdb comes with mod_perl.
1N/ASomething similar should be distributed with perl.
1N/AThe proper way to do this is to use and extend Devel::DebugInit.
1N/ADevel::DebugInit also needs to be extended to support threads.
1N/ASee p5p archives for late
May/early June 2001 for a recent discussion
1N/A=head2 truncate to the people
1N/AOne can emulate ftruncate() using F_FREESP and F_CHSIZ fcntls
1N/A(see the UNIX FAQ for details). This needs to go somewhere near
1N/AOne can emulate truncate() easily if one has ftruncate().
1N/A=head2 Unicode in Filenames
1N/Achdir, chmod, chown, chroot, exec, glob, link, lstat, mkdir, open,
1N/Aopendir, qx, readdir, readlink, rename, rmdir, stat, symlink, sysopen,
1N/Asystem, truncate, unlink, utime, -X. All these could potentially accept
1N/AUnicode filenames either as input or output (and in the case of system
1N/Aand qx Unicode in general, as input or output
to/from the shell).
1N/AWhether a filesystem - an operating system pair understands Unicode in
1N/AKnown combinations that have some level of understanding include
1N/AMicrosoft NTFS, Apple HFS+ (In Mac OS 9 and X) and Apple UFS (in Mac
1N/AOS X), NFS v4 is rumored to be Unicode, and of course Plan 9. How to
1N/Acreate Unicode filenames, what forms of Unicode are accepted and used
1N/A(UCS-2, UTF-16, UTF-8), what (if any) is the normalization form used,
1N/Aand so on, varies. Finding the right level of interfacing to Perl
1N/Arequires some thought. Remember that an OS does not implicate a
1N/A(The Windows -C command flag "wide API support" has been at least
1N/Atemporarily retired in 5.8.1, and the -C has been repurposed, see
1N/A=head1 Unicode in %ENV
1N/ACurrently the %ENV entries are always byte strings.
1N/A=head1 Recently done things
1N/AThese are things which have been on the todo lists in previous releases
1N/Abut have recently been completed.
1N/A=head2 Alternative RE syntax module
1N/AThe C<Regexp::English> module, available from the CPAN, provides this:
1N/A my $re = Regexp::English
1N/A -> literal('Flippers')
1N/A=head2 Safe signal handling
1N/AA new signal model went into 5.7.1 without much fanfare. Operations and
1N/AC<malloc>s are no longer interrupted by signals, which are handled
1N/Abetween opcodes. This means that C<PERL_ASYNC_CHECK> now actually does
1N/Asomething. However, there are still a few things that need to be done.
1N/AModules which implement arrays in terms of strings, substrings or files
1N/Acan be found on the CPAN.
1N/AC<Time::HiRes> has been integrated into the core.
1N/A=head2 setitimer and getimiter
1N/AAdding C<Time::HiRes> got us this too.
1N/A=head2 Testing __DIE__ hook
1N/ATests have been added.
1N/A=head2 CPP equivalent in Perl
1N/AA C Yardley will probably have done this by the time you can read this.
1N/AThis allows for a generalization of the C constant detection used in
1N/A=head2 Explicit switch statements
1N/AC<
Switch.pm> has been integrated into the core to give you all manner of
1N/ANick Ing-Simmons has made UTF-EBCDIC (UTR13) work with Perl.
1N/AAlthough there are probably some small bugs to be rooted out, Jarkko
1N/AHietaniemi has made regular expressions polymorphic between bytes and
1N/A=head2 perlcc to produce executable
1N/AC<perlcc> was recently rewritten, and can now produce standalone
1N/A=head2 END blocks saved in compiled output
1N/A=head2 Secure temporary file module
1N/ATim Jenness' C<File::Temp> is now in core.
1N/A=head2 Integrate Time::HiRes
1N/AThis module is now part of core.
1N/A=head2 Turn Cwd into XS
1N/ABenjamin Sugars has done this.
1N/A=head2 Mmap for input
1N/ANick Ing-Simmons' C<perlio> supports an C<mmap> IO method.
1N/AC<Encode> provides this.
1N/A=head2 Add sockatmark support
1N/A=head2 Mailing list archives
1N/ASince 5.8.0 perl uses the RT bug tracking system from Jesse Vincent,
1N/A=head2 Integrate MacPerl
1N/AChris Nandor and Matthias Neeracher have integrated the MacPerl changes
1N/A=head2 Web "nerve center" for Perl
1N/A=head2 Regular expression tutorial
1N/AC<perlretut>, provided by Mark Kvale.
1N/A=head2 Debugging Tutorial
1N/AC<perldebtut>, written by Richard Foley.
1N/A=head2 Integrate new modules
1N/AJarkko has been integrating madly into
5.7.x 1N/A=head2 Integrate profiler
1N/AC<Devel::DProf> is now a core module.
1N/A=head2 Y2K error detection
1N/AThere's a configure option to detect unsafe concatenation with "19", and
1N/Aa CPAN module. (C<D'oh::Year>)
1N/A=head2 Regular expression debugger
1N/AWhile not part of core, Mark-Jason Dominus has written C<Rx> and has
1N/Aalso come up with a generalised strategy for regular expression
1N/AThat's, uh, F<podchecker>
1N/A=head2 "Dynamic" lexicals
1N/A=head2 Cache precompiled modules
1N/A=head1 Deprecated Wishes
1N/AThese are items which used to be in the todo file, but have been
1N/Adeprecated for some reason.
1N/A=head2 Loop control on do{}
1N/AThis would break old code; use C<do{{ }}> instead.
1N/A=head2 Lexically scoped typeglobs
1N/ANot needed now we have lexical IO handles.
1N/ADamian Conway's text formatting modules seem to be the Way To Go.
1N/A=head2 Generalised want()/caller())
1N/ARobin Houston's C<Want> module does this.
1N/A=head2 Named prototypes
1N/AThis seems to be delayed until Perl 6.
1N/A=head2 Built-in globbing
1N/AThe C<File::Glob> module has been used to replace the C<glob> function.
1N/A=head2 Regression tests for suidperl
1N/AC<suidperl> is deprecated in favour of common sense.
1N/A=head2 Cached hash values
1N/AWe have shared hash keys, which perform the same job.
1N/A=head2 Add compression modules
1N/AThe compression modules are a little heavy; meanwhile, Nick Clark is
1N/Aworking on experimental pragmata to do transparent decompression on
1N/ACould not get consensus on P5P about this.
1N/A=head2 Remove distinction between functions and operators
1N/ACaution: highly flammable.
1N/A=head2 Make XS easier to use
1N/AUse C<Inline> instead, or SWIG.
1N/A=head2 Make embedding easier to use
1N/A=head2 my $Package::variable
1N/A=head2 "or" tests defined, not truth
1N/ASuggesting this on P5P B<will> cause a boring and interminable flamewar.
1N/A=head2 "class"-based lexicals
1N/AUse flyweight objects, secure hashes or, dare I say it, pseudo-hashes instead.
1N/A(Or whatever will replace pseudohashes in 5.10.)
1N/AC<ByteLoader> covers this.
1N/A=head2 Lazy evaluation / tail recursion removal
1N/AC<List::Util> gives first() (a short-circuiting grep); tail recursion
1N/Aremoval is done manually, with C<goto &whoami;>. (However, MJD has
1N/Afound that C<goto &whoami> introduces a performance penalty, so maybe
1N/Athere should be a way to do this after all: C<sub foo {START: ... goto
1N/A=head2 Make "use utf8" the default
1N/ABecause of backward compatibility this is difficult: scripts could not
1N/Acontain B<any legacy eight-bit data> (like Latin-1) anymore, even in
1N/Astring literals or pod. Also would introduce a measurable slowdown of
1N/Aat least few percentages since all regular expression operations would
1N/Abe done in full UTF-8. But if you want to try this, add
1N/A-DUSE_UTF8_SCRIPTS to your compilation flags.
1N/A=head2 Unicode collation and normalization
1N/AThe Unicode::Collate and Unicode::Normalize modules
1N/Aby SADAHIRO Tomoyuki have been included since 5.8.0.
1N/AWolfgang Laun finished what Simon Cozens started.