X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperltodo.pod;h=0e5d8a74ef6c16d770f3f2dff66716d479b59f8a;hb=d7133549e15d907b18e0c1873e57e635dc9d6424;hp=e715a6145ad15d5c3d4fc831dc9704b507a857e2;hpb=8d3e8850e58492e2cf837de0c4e42975e5f9ab0e;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/pod/perltodo.pod b/pod/perltodo.pod
index e715a61..0e5d8a7 100644
--- a/pod/perltodo.pod
+++ b/pod/perltodo.pod
@@ -87,10 +87,8 @@ C<Numeric Type>, C<East Asian Width>.
 
     Case Mappings? http://www.unicode.org/unicode/reports/tr21/
 
-lc(), uc(), lcfirst(), and ucfirst() work only for some of the
-simplest cases, where the mapping goes from a single Unicode character
-to another single Unicode character.  See lib/unicore/SpecCase.txt
-(and CaseFold.txt).
+Mostly implemented (all of 1:1, 1:N, N:1), only the "final sigma"
+and locale-specific rules of SpecCase are not implemented.
 
 =item *
 
@@ -112,17 +110,37 @@ class subtraction.
 
 	http://www.unicode.org/unicode/reports/tr18/
 
-=head2 use Thread for iThreads
+=head2 Work out exit/die semantics for threads
 
-Artur Bergman's C<iThreads> module is a start on this, but needs to
-be more mature.
+There are some suggestions to use for example something like this:
+default to "(thread exiting first will) wait for the other threads
+until up to 60 seconds".  Other possibilities:
 
-=head2 make perl_clone optionally clone ops
+    use threads wait => 0;
 
-So that pseudoforking, mod_perl, iThreads and nvi will work properly
-(but not as efficiently) until the regex engine is fixed to be threadsafe.
+Do not wait.
 
-=head2 Work out exit/die semantics for threads
+    use threads wait_for => 10;
+
+Wait up to 10 seconds.
+
+    use threads wait_for => -1;
+
+Wait for ever.
+
+http://archive.develooper.com/perl5-porters@perl.org/msg79618.html
+
+=head2 Better support for nonpreemptive threading systems like GNU pth
+
+To better support nonpreemptive threading systems, perhaps some of the
+blocking functions internally in Perl should do a yield() before a
+blocking call.  (Now certain threads tests ({basic,list,thread.t})
+simply do a yield() before they sleep() to give nonpreemptive thread
+implementations a chance).
+
+In some cases, like the GNU pth, which has replacement functions that
+are nonblocking (pth_select instead of select), maybe Perl should be
+using them instead when built for threading.
 
 =head2 Typed lexicals for compiler
 
@@ -170,17 +188,13 @@ One possible solution would be to adopt/support ICU:
 
 	http://oss.software.ibm.com/developerworks/opensource/icu/project/
 
-=head2 Thread-safe regexes
-
-The regular expression engine is currently non-threadsafe.
-
 =head2 Arithmetic on non-Arabic numerals
 
 C<[1234567890]> aren't the only numerals any more.
 
 =head2 POSIX Unicode character classes
 
-(C<[=a=]> for equivalance classes, C<[.ch.]> for collation.)
+(C<[=a=]> for equivalence classes, C<[.ch.]> for collation.)
 These are dependent on Unicode normalization and collation.
 
 =head2 Factoring out common suffices/prefices in regexps (trie optimization)
@@ -247,7 +261,7 @@ C<&>, C<oct>, C<hex> and C<pack>.
 =head2 Replace pod2html with something using Pod::Parser
 
 The CPAN module C<Marek::Pod::Html> may be a more suitable basis for a
-C<pod2html> convertor; the current one duplicates the functionality
+C<pod2html> converter; the current one duplicates the functionality
 abstracted in C<Pod::Parser>, which makes updating the POD language
 difficult.
 
@@ -404,12 +418,6 @@ This is to speed up
 C<qr//> already gives us a way of saving compiled regexps, but it should
 be done automatically.
 
-=head2 Re-entrant functions
-
-Add configure probes for C<_r> forms of system calls and fit them to the
-core. Unfortunately, calling conventions for these functions and not
-standardised.
-
 =head2 Cross-compilation support
 
 Bart Schuller reports that using C<microperl> and a cross-compiler, he
@@ -542,6 +550,18 @@ even with the same keys.
 This should be allowed if the new keyset is a subset of the old
 keyset.  May require more extra code than we'd like in pp_aassign.
 
+=head2 Should overload be inheritable?
+
+Should overload be 'contagious' through @ISA so that derived classes
+would inherit their base classes' overload definitions?  What to do
+in case of overload conflicts?
+
+=head2 Taint rethink
+
+Should taint be stopped from affecting control flow, if ($tainted)?
+Should tainted symbolic method calls and subref calls be stopped?
+(Look at Ruby's $SAFE levels for inspiration?)
+
 =head1 Vague ideas
 
 Ideas which have been discussed, and which may or may not happen.