This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
c6d64bd061e9405685af6ed907fe6ef306d88551
[perl5.git] / pod / perltodo.pod
1 =head1 NAME
2
3 perltodo - Perl TO-DO List
4
5 =head1 DESCRIPTION
6
7 This is a list of wishes for Perl.  Send updates to
8 I<perl5-porters@perl.org>.  If you want to work on any of these
9 projects, be sure to check the perl5-porters archives for past ideas,
10 flames, and propaganda.  This will save you time and also prevent you
11 from implementing something that Larry has already vetoed.  One set
12 of archives may be found at:
13
14     http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/
15
16 =head1 To do during 5.6.x
17
18 =head2 Support for I/O disciplines
19
20 C<perlio> provides this, but the interface could be a lot more
21 straightforward.
22
23 =head2 Autoload bytes.pm
24
25 When the lexer sees, for instance, C<bytes::length>, it should
26 automatically load the C<bytes> pragma.
27
28 =head2 Make "\u{XXXX}" et al work
29
30 Danger, Will Robinson! Discussing the semantics of C<"\x{F00}">,
31 C<"\xF00"> and C<"\U{F00}"> on P5P I<will> lead to a long and boring
32 flamewar.
33
34 =head2 Create a char *sv_pvprintify(sv, STRLEN *lenp, UV flags)
35
36 For displaying PVs with control characters, embedded nulls, and Unicode.
37 This would be useful for printing warnings, or data and regex dumping,
38 not_a_number(), and so on.
39
40 Requirements: should handle both byte and UTF8 strings.  isPRINT()
41 characters printed as-is, character less than 256 as \xHH, Unicode
42 characters as \x{HHH}.  Don't assume ASCII-like, either, get somebody
43 on EBCDIC to test the output.
44
45 Possible options, controlled by the flags:
46 - whitespace (other than ' ' of isPRINT()) printed as-is
47 - use isPRINT_LC() instead of isPRINT()
48 - print control characters like this: "\cA"
49 - print control characters like this: "^A"
50 - non-PRINTables printed as '.' instead of \xHH
51 - use \OOO instead of \xHH
52 - use the C/Perl-metacharacters like \n, \t
53 - have a maximum length for the produced string (read it from *lenp)
54 - append a "..." to the produced string if the maximum length is exceeded
55 - really fancy: print unicode characters as \N{...}
56
57 =head2 Overloadable regex assertions
58
59 This may or may not be possible with the current regular expression
60 engine. The idea is that, for instance, C<\b> needs to be
61 algorithmically computed if you're dealing with Thai text. Hence, the
62 B<\b> assertion wants to be overloaded by a function.
63
64 =head2 Unicode collation and normalization
65
66 Simon Cozens promises to work on this.
67
68     Collation?     http://www.unicode.org/unicode/reports/tr10/
69     Normalization? http://www.unicode.org/unicode/reports/tr15/
70
71 =head2 Unicode case mappings 
72
73     Case Mappings? http://www.unicode.org/unicode/reports/tr21/
74
75 =head2 Unicode regular expression character classes
76
77 They have some tricks Perl doesn't yet implement like character
78 class subtraction.
79
80         http://www.unicode.org/unicode/reports/tr18/
81
82 =head2 use Thread for iThreads
83
84 Artur Bergman's C<iThreads> module is a start on this, but needs to
85 be more mature.
86
87 =head2 make perl_clone optionally clone ops
88
89 So that pseudoforking, mod_perl, iThreads and nvi will work properly
90 (but not as efficiently) until the regex engine is fixed to be threadsafe.
91
92 =head2 Work out exit/die semantics for threads
93
94 =head2 Typed lexicals for compiler
95
96 =head2 Compiler workarounds for Win32
97
98 =head2 AUTOLOADing in the compiler
99
100 =head2 Fixing comppadlist when compiling
101
102 =head2 Cleaning up exported namespace
103
104 =head2 Complete signal handling
105
106 Add C<PERL_ASYNC_CHECK> to opcodes which loop; replace C<sigsetjmp> with
107 C<sigjmp>; check C<wait> for signal safety.
108
109 =head2 Out-of-source builds
110
111 This was done for 5.6.0, but needs reworking for 5.7.x
112
113 =head2 POSIX realtime support
114
115 POSIX 1003.1 1996 Edition support--realtime stuff: POSIX semaphores,
116 message queues, shared memory, realtime clocks, timers, signals (the
117 metaconfig units mostly already exist for these)
118
119 =head2 UNIX98 support
120
121 Reader-writer locks, realtime/asynchronous IO
122
123 =head2 IPv6 Support
124
125 There are non-core modules, such as C<Net::IPv6>, but these will need
126 integrating when IPv6 actually starts to really happen.  See RFC 2292
127 and RFC 2553.
128
129 =head2 Long double conversion
130
131 Floating point formatting is still causing some weird test failures.
132
133 =head2 Locales
134
135 Locales and Unicode interact with each other in unpleasant ways.
136 One possible solution would be to adopt/support ICU:
137
138         http://oss.software.ibm.com/developerworks/opensource/icu/project/
139
140 =head2 Thread-safe regexes
141
142 The regular expression engine is currently non-threadsafe.
143
144 =head2 Arithmetic on non-Arabic numerals
145
146 C<[1234567890]> aren't the only numerals any more.
147
148 =head2 POSIX Unicode character classes
149
150 ([=a=] for equivalance classes, [.ch.] for collation.)
151 These are dependent on Unicode normalization and collation.
152
153 =head2 Factoring out common suffices/prefices in regexps (trie optimization)
154
155 Currently, the user has to optimize C<foo|far> and C<foo|goo> into
156 C<f(?:oo|ar)> and C<[fg]oo> by hand; this could be done automatically.
157
158 =head2 Security audit shipped utilities
159
160 All the code we ship with Perl needs to be sensible about temporary file
161 handling, locking, input validation, and so on.
162
163 =head2 Custom opcodes
164
165 Have a way to introduce user-defined opcodes without the subroutine call
166 overhead of an XSUB; the user should be able to create PP code. Simon
167 Cozens has some ideas on this.
168
169 =head2 spawnvp() on Win32
170
171 Win32 has problems spawning processes, particularly when the arguments
172 to the child process contain spaces, quotes or tab characters.
173
174 =head2 DLL Versioning
175
176 Windows needs a way to know what version of a XS or C<libperl> DLL it's
177 loading.
178
179 =head2 Introduce @( and @)
180
181 C<$(> may return "foo bar baz". Unfortunately, since groups can
182 theoretically have spaces in their names, this could be one, two or
183 three groups.
184
185 =head2 Floating point handling
186
187 C<NaN> and C<inf> support is particularly troublesome.
188 (fp_classify(), fp_class(), fp_class_d(), class(), isinf(),
189 isfinite(), finite(), isnormal(), unordered(), <ieeefp.h>,
190 <fp_class.h> (there are metaconfig units for all these) (I think),
191 fp_setmask(), fp_getmask(), fp_setround(), fp_getround()
192 (no metaconfig units yet for these).  Don't forget finitel(), fp_classl(),
193 fp_class_l(), (yes, both do, unfortunately, exist), and unorderedl().)
194
195 As of Perl 5.6.1 is a Perl macro, Perl_isnan().
196
197 =head2 IV/UV preservation
198
199 Nicholas Clark has done a lot of work on this, but work is continuing.
200 C<+>, C<-> and C<*> work, but guards need to be in place for C<%>, C</>,
201 C<&>, C<oct>, C<hex> and C<pack>.
202
203 =head2 Replace pod2html with something using Pod::Parser
204
205 The CPAN module C<Malik::Pod::Html> may be a more suitable basis for a
206 C<pod2html> convertor; the current one duplicates the functionality
207 abstracted in C<Pod::Parser>, which makes updating the POD language
208 difficult.
209
210 =head2 Automate module testing on CPAN
211
212 When a new Perl is being beta tested, porters have to manually grab
213 their favourite CPAN modules and test them - this should be done
214 automatically.
215
216 =head2 sendmsg and recvmsg
217
218 We have all the other BSD socket functions but these. There are
219 metaconfig units for these functions which can be added. To avoid these
220 being new opcodes, a solution similar to the way C<sockatmark> was added
221 would be preferable. (Autoload the C<IO::whatever> module.)
222
223 =head2 Rewrite perlre documentation
224
225 The new-style patterns need full documentation, and the whole document
226 needs to be a lot clearer.
227
228 =head2 Convert example code to IO::Handle filehandles
229
230 =head2 Document Win32 choices
231
232 =head2 Check new modules
233
234 =head2 Make roffitall find pods and libs itself
235
236 Simon Cozens has done some work on this but it needs a rethink.
237
238 =head1 To do at some point
239
240 These are ideas that have been regularly tossed around, that most
241 people believe should be done maybe during 5.8.x
242
243 =head2 Remove regular expression recursion
244
245 Because the regular expression engine is recursive, badly designed
246 expressions can lead to lots of recursion filling up the stack. Ilya
247 claims that it is easy to convert the engine to being iterative, but
248 this has still not yet been done. There may be a regular expression
249 engine hit squad meeting at TPC5.
250
251 =head2 Memory leaks after failed eval
252
253 Perl will leak memory if you C<eval "hlagh hlagh hlagh hlagh">. This is
254 partially because it attempts to build up an op tree for that code and
255 doesn't properly free it. The same goes for non-syntactically-correct
256 regular expressions. Hugo looked into this, but decided it needed a
257 mark-and-sweep GC implementation. 
258
259 Alan notes that: The basic idea was to extend the parser token stack
260 (C<YYSTYPE>) to include a type field so we knew what sort of thing each
261 element of the stack was.  The F<<perly.c> code would then have to be
262 postprocessed to record the type of each entry on the stack as it was
263 created, and the parser patched so that it could unroll the stack
264 properly on error.
265
266 This is possible to do, but would be pretty messy to implement, as it
267 would rely on even more sed hackery in F<perly.fixer>.
268
269 =head2 pack "(stuff)*"
270
271 That's to say, C<pack "(sI)40"> would be the same as C<pack "sI"x40>
272
273 =head2 bitfields in pack
274
275 =head2 Cross compilation
276
277 Make Perl buildable with a cross-compiler. This will play havoc with
278 Configure, which needs to how how the target system will respond to
279 its tests; maybe C<microperl> will be a good starting point here.
280 (Indeed, Bart Schuller reports that he compiled up C<microperl> for
281 the Agenda PDA and it works fine.)  A really big spanner in the works
282 is the bootstrapping build process of Perl: if the filesystem the
283 target systems sees is not the same what the build host sees, various
284 input, output, and (Perl) library files need to be copied back and forth.
285
286 As of 5.8.0 Configure mostly works for cross-compilation
287 (used successfully for iPAQ Linux), miniperl gets built,
288 but then building DynaLoader (and other extensions) fails
289 since MakeMaker knows nothing of cross-compilation.
290 (See INSTALL/Cross-compilation for the state of things.)
291
292 =head2 Perl preprocessor / macros
293
294 Source filters help with this, but do not get us all the way. For
295 instance, it should be possible to implement the C<??> operator somehow;
296 source filters don't (quite) cut it.
297
298 =head2 Perl lexer in Perl
299
300 Damian Conway is planning to work on this, but it hasn't happened yet.
301
302 =head2 Using POSIX calls internally
303
304 When faced with a BSD vs. SySV -style interface to some library or
305 system function, perl's roots show in that it typically prefers the BSD
306 interface (but falls back to the SysV one).  One example is getpgrp().
307 Other examples include C<memcpy> vs. C<bcopy>.  There are others, mostly in
308 F<<pp_sys.c>.
309
310 Mostly, this item is a suggestion for which way to start a journey into
311 an C<#ifdef> forest.  It is not primarily a suggestion to eliminate any of
312 the C<#ifdef> forests.
313
314 POSIX calls are perhaps more likely to be portable to unexpected
315 architectures. They are also perhaps more likely to be actively
316 maintained by a current vendor.  They are also perhaps more likely to be
317 available in thread-safe versions, if appropriate.
318
319 =head2 -i rename file when changed
320
321 It's only necessary to rename a file when inplace editing when the file
322 has changed. Detecting a change is perhaps the difficult bit.
323
324 =head2 All ARGV input should act like E<lt>E<gt>
325
326 =head2 Support for rerunning debugger
327
328 There should be a way of restarting the debugger on demand.
329
330 =head2 Test Suite for the Debugger
331
332 The debugger is a complex piece of software and fixing something
333 here may inadvertently break something else over there.  To tame
334 this chaotic behaviour, a test suite is necessary. 
335
336 =head2 my sub foo { }
337
338 The basic principle is sound, but there are problems with the semantics
339 of self-referential and mutually referential lexical subs: how to
340 declare the subs?
341
342 =head2 One-pass global destruction
343
344 Sweeping away all the allocated memory in one go is a laudable goal, but
345 it's difficult and in most cases, it's easier to let the memory get
346 freed by exiting.
347
348 =head2 Rewrite regexp parser
349
350 There has been talk recently of rewriting the regular expression parser
351 to produce an optree instead of a chain of opcodes; it's unclear whether
352 or not this would be a win. 
353
354 =head2 Cache recently used regexps
355
356 This is to speed up 
357
358     for my $re (@regexps) {
359         $matched++ if /$re/
360     }
361
362 C<qr//> already gives us a way of saving compiled regexps, but it should
363 be done automatically.
364
365 =head2 Re-entrant functions
366
367 Add configure probes for C<_r> forms of system calls and fit them to the
368 core. Unfortunately, calling conventions for these functions and not
369 standardised.
370
371 =head2 Cross-compilation support
372
373 Bart Schuller reports that using C<microperl> and a cross-compiler, he
374 got Perl working on the Agenda PDA. However, one cannot build a full
375 Perl because Configure needs to get the results for the target platform,
376 for the host.
377
378 =head2 Bit-shifting bitvectors
379
380 Given:
381
382     vec($v, 1000, 1) = 1;
383
384 One should be able to do
385
386     $v <<= 1;
387
388 and have the 999'th bit set.
389
390 Currently if you try with shift bitvectors you shift the NV/UV, instead
391 of the bits in the PV.  Not very logical.
392
393 =head2 debugger pragma
394
395 The debugger is implemented in Perl in F<perl5db.pl>; turning it into a
396 pragma should be easy, but making it work lexically might be more
397 difficult. Fiddling with C<$^P> would be necessary.
398
399 =head2 use less pragma
400
401 Identify areas where speed/memory tradeoffs can be made and have a hint
402 to switch between them.
403
404 =head2 switch structures
405
406 Although we have C<Switch.pm> in core, Larry points to the dormant
407 C<nswitch> and C<cswitch> ops in F<pp.c>; using these opcodes would be
408 much faster.
409
410 =head2 Cache eval tree
411
412 =head2 rcatmaybe
413
414 =head2 Shrink opcode tables
415
416 =head2 Optimize away @_
417
418 Look at the "reification" code in C<av.c>
419
420 =head2 Prototypes versus indirect objects
421
422 Currently, indirect object syntax bypasses prototype checks.
423
424 =head2 Install HMTL
425
426 HTML versions of the documentation need to be installed by default; a
427 call to C<installhtml> from C<installperl> may be all that's necessary.
428
429 =head2 Prototype method calls
430
431 =head2 Return context prototype declarations
432
433 =head2 magic_setisa
434
435 =head2 Garbage collection
436
437 There have been persistent mumblings about putting a mark-and-sweep
438 garbage detector into Perl; Alan Burlison has some ideas about this.
439
440 =head2 IO tutorial
441
442 Mark-Jason Dominus has the beginnings of one of these.
443
444 =head2 pack/unpack tutorial
445
446 Simon Cozens has the beginnings of one of these.
447
448 =head2 Rewrite perldoc
449
450 There are a few suggestions for what to do with C<perldoc>: maybe a
451 full-text search, an index function, locating pages on a particular
452 high-level subject, and so on.
453
454 =head2 Install .3p manpages
455
456 This is a bone of contention; we can create C<.3p> manpages for each
457 built-in function, but should we install them by default? Tcl does this,
458 and it clutters up C<apropos>.
459
460 =head2 Unicode tutorial
461
462 Simon Cozens promises to do this before he gets old.
463
464 =head2 Update POSIX.pm for 1003.1-2
465
466 =head2 Retargetable installation
467
468 Allow C<@INC> to be changed after Perl is built.
469
470 =head2 POSIX emulation on non-POSIX systems
471
472 Make C<POSIX.pm> behave as POSIXly as possible everywhere, meaning we
473 have to implement POSIX equivalents for some functions if necessary.
474
475 =head2 Rename Win32 headers
476
477 =head2 Finish off lvalue functions
478
479 They don't work in the debugger, and they don't work for list or hash
480 slices.
481
482 =head2 Update sprintf documentation
483
484 Hugo van der Sanden plans to look at this.
485
486 =head2 Use fchown/fchmod internally
487
488 This has been done in places, but needs a thorough code review.
489 Also fchdir is available in some platforms.
490
491 =head1 Vague ideas
492
493 Ideas which have been discussed, and which may or may not happen.
494
495 =head2 ref() in list context
496
497 It's unclear what this should do or how to do it without breaking old
498 code.
499
500 =head2 Make tr/// return histogram of characters in list context
501
502 There is a patch for this, but it may require Unicodification.
503
504 =head2 Compile to real threaded code
505
506 =head2 Structured types
507
508 =head2 Modifiable $1 et al.
509
510     ($x = "elephant") =~ /e(ph)/;
511     $1 = "g"; # $x = "elegant"
512
513 What happens if there are multiple (nested?) brackets? What if the
514 string changes between the match and the assignment?
515
516 =head2 Procedural interfaces for IO::*, etc.
517
518 Some core modules have been accused of being overly-OO. Adding
519 procedural interfaces could demystify them.
520
521 =head2 RPC modules
522
523 =head2 Attach/detach debugger from running program
524
525 With C<gdb>, you can attach the debugger to a running program if you
526 pass the process ID. It would be good to do this with the Perl debugger
527 on a running Perl program, although I'm not sure how it would be done.
528
529 =head2 Alternative RE syntax module
530
531     use Regex::Newbie;
532     $re = Regex::Newbie->new
533                        ->start
534                        ->match("foo")
535                        ->repeat(Regex::Newbie->class("char"),3)
536                        ->end;
537     /$re/;
538
539 =head2 GUI::Native
540
541 A non-core module that would use "native" GUI to create graphical
542 applications.
543
544 =head2 foreach(reverse ...)
545
546 Currently
547
548     foreach (reverse @_) { ... }
549
550 puts C<@_> on the stack, reverses it putting the reversed version on the
551 stack, then iterates forwards. Instead, it could be special-cased to put
552 C<@_> on the stack then iterate backwards.
553
554 =head2 Constant function cache
555
556 =head2 Approximate regular expression matching
557
558 =head1 Ongoing
559
560 These items B<always> need doing:
561
562 =head2 Update guts documentation
563
564 Simon Cozens tries to do this when possible, and contributions to the
565 C<perlapi> documentation is welcome.
566
567 =head2 Add more tests
568
569 Michael Schwern will donate $500 to Yet Another Society when all core
570 modules have tests.
571
572 =head2 Update auxiliary tools
573
574 The code we ship with Perl should look like good Perl 5.
575
576 =head1 Recently done things
577
578 These are things which have been on the todo lists in previous releases
579 but have recently been completed.
580
581 =head2 Safe signal handling
582
583 A new signal model went into 5.7.1 without much fanfare. Operations and
584 C<malloc>s are no longer interrupted by signals, which are handled
585 between opcodes. This means that C<PERL_ASYNC_CHECK> now actually does
586 something. However, there are still a few things that need to be done.
587
588 =head2 Tie Modules
589
590 Modules which implement arrays in terms of strings, substrings or files
591 can be found on the CPAN.
592
593 =head2 gettimeofday
594
595 C<Time::Hires> has been integrated into the core.
596
597 =head2 setitimer and getimiter
598
599 Adding C<Time::Hires> got us this too.
600
601 =head2 Testing __DIE__ hook
602
603 Tests have been added.
604
605 =head2 CPP equivalent in Perl
606
607 A C Yardley will probably have done this by the time you can read this.
608 This allows for a generalization of the C constant detection used in
609 building C<Errno.pm>.
610
611 =head2 Explicit switch statements
612
613 C<Switch.pm> has been integrated into the core to give you all manner of
614 C<switch...case> semantics.
615
616 =head2 autocroak
617
618 This is C<Fatal.pm>.
619
620 =head2 UTF/EBCDIC
621
622 Nick Ing-Simmons has made UTF-EBCDIC (UTR13) work with Perl.
623
624     EBCDIC?        http://www.unicode.org/unicode/reports/tr16/
625
626 =head2 UTF Regexes
627
628 Although there are probably some small bugs to be rooted out, Jarkko
629 Hietaniemi has made regular expressions polymorphic between bytes and
630 characters.
631
632 =head2 perlcc to produce executable
633
634 C<perlcc> was recently rewritten, and can now produce standalone
635 executables.
636
637 =head2 END blocks saved in compiled output
638
639 =head2 Secure temporary file module
640
641 Tim Jenness' C<File::Temp> is now in core.
642
643 =head2 Integrate Time::HiRes
644
645 This module is now part of core.
646
647 =head2 Turn Cwd into XS
648
649 Benjamin Sugars has done this.
650
651 =head2 Mmap for input
652
653 Nick Ing-Simmons' C<perlio> supports an C<mmap> IO method.
654
655 =head2 Byte to/from UTF8 and UTF8 to/from local conversion
656
657 C<Encode> provides this.
658
659 =head2 Add sockatmark support
660
661 Added in 5.7.1
662
663 =head2 Mailing list archives
664
665 http://lists.perl.org/, http://archive.develooper.com/
666
667 =head2 Bug tracking
668
669 Richard Foley has written the bug tracking system at http://bugs.perl.org/
670
671 =head2 Integrate MacPerl
672
673 Chris Nandor and Matthias Neeracher have integrated the MacPerl changes
674 into 5.6.0.
675
676 =head2 Web "nerve center" for Perl
677
678 http://use.perl.org/ is what you're looking for.
679
680 =head2 Regular expression tutorial
681
682 C<perlretut>, provided by Mark Kvale.
683
684 =head2 Debugging Tutorial
685
686 C<perldebtut>, written by Richard Foley.
687
688 =head2 Integrate new modules
689
690 Jarkko has been integrating madly into 5.7.x
691
692 =head2 Integrate profiler
693
694 C<Devel::DProf> is now a core module.
695
696 =head2 Y2K error detection
697
698 There's a configure option to detect unsafe concatenation with "19", and
699 a CPAN module. (C<D'oh::Year>)
700
701 =head2 Regular expression debugger
702
703 While not part of core, Mark-Jason Dominus has written C<Rx> and has
704 also come up with a generalised strategy for regular expression
705 debugging.
706
707 =head2 POD checker
708
709 That's, uh, F<podchecker>
710
711 =head2 "Dynamic" lexicals
712
713 =head2 Cache precompiled modules
714
715 =head1 Deprecated Wishes
716
717 These are items which used to be in the todo file, but have been
718 deprecated for some reason.
719
720 =head2 Loop control on do{}
721
722 This would break old code; use C<do{{ }}> instead.
723
724 =head2 Lexically scoped typeglobs
725
726 Not needed now we have lexical IO handles.
727
728 =head2 format BOTTOM
729
730 =head2 report HANDLE
731
732 Damian Conway's text formatting modules seem to be the Way To Go.
733
734 =head2 Generalised want()/caller())
735
736 =head2 Named prototypes
737
738 These both seem to be delayed until Perl 6.
739
740 =head2 Built-in globbing
741
742 The C<File::Glob> module has been used to replace the C<glob> function.
743
744 =head2 Regression tests for suidperl
745
746 C<suidperl> is deprecated in favour of common sense.
747
748 =head2 Cached hash values
749
750 We have shared hash keys, which perform the same job.
751
752 =head2 Add compression modules
753
754 The compression modules are a little heavy; meanwhile, Nick Clark is
755 working on experimental pragmata to do transparent decompression on
756 input.
757
758 =head2 Reorganise documentation into tutorials/references
759
760 Could not get consensus on P5P about this.
761
762 =head2 Remove distinction between functions and operators
763
764 Caution: highly flammable.
765
766 =head2 Make XS easier to use
767
768 Use C<Inline> instead, or SWIG.
769
770 =head2 Make embedding easier to use
771
772 Use C<Inline::CPR>.
773
774 =head2 man for perl
775
776 See the Perl Power Tools. (http://language.perl.com/ppt/)
777
778 =head2 my $Package::variable
779
780 Use C<our> instead.
781
782 =head2 "or" tests defined, not truth
783
784 Suggesting this on P5P B<will> cause a boring and interminable flamewar.
785
786 =head2 "class"-based lexicals
787
788 Use flyweight objects, secure hashes or, dare I say it, pseudo-hashes instead.
789 (Or whatever will replace pseudohashes in 5.10.)
790
791 =head2 byteperl
792
793 C<ByteLoader> covers this.
794
795 =head2 Lazy evaluation / tail recursion removal
796
797 C<List::Util> gives first() (a short-circuiting grep); tail recursion
798 removal is done manually, with C<goto &whoami;>. (However, MJD has
799 found that C<goto &whoami> introduces a performance penalty, so maybe
800 there should be a way to do this after all: C<sub foo {START: ... goto
801 START;> is better.)
802
803 =head2 Make "use utf8" the default
804
805 Because of backward compatibility this is difficult: scripts could not
806 contain B<any legacy eight-bit data> (like Latin-1) anymore, even in
807 string literals or pod.  Also would introduce a measurable slowdown of
808 at least few percentages since all regular expression operations would
809 be done in full UTF-8.  But if you want to try this, add
810 -DUSE_UTF8_SCRIPTS to your compilation flags.
811
812