[svn:perl6-synopsis] r10250 - doc/trunk/design/syn

Author: larry
Date: Sun Jul 16 18:58:53 2006
New Revision: 10250

Modified:
   doc/trunk/design/syn/S03.pod
   doc/trunk/design/syn/S04.pod
   doc/trunk/design/syn/S06.pod

Log:
Renamed .id to .valid as a pun on "value id".


Modified: doc/trunk/design/syn/S03.pod
==============================================================================
--- doc/trunk/design/syn/S03.pod	(original)
+++ doc/trunk/design/syn/S03.pod	Sun Jul 16 18:58:53 2006
@@ -12,9 +12,9 @@
 
   Maintainer: Larry Wall <larry@wall.org>
   Date: 8 Mar 2004
-  Last Modified: 15 Jul 2006
+  Last Modified: 16 Jul 2006
   Number: 3
-  Version: 48
+  Version: 49
 
 =head1 Changes to existing operators
 
@@ -341,15 +341,15 @@
 C<Array> objects, but it is true that C<@a === @a> because those are
 the same C<Array> object).
 
-Any object type may pretend to be a value type by defining a C<.id>
+Any object type may pretend to be a value type by defining a C<.valid>
 method which returns a value type that can be recursively compared
 using C<===>, or in cases where that is impractical, by overloading
 C<===> such that the comparison treats values consistently with their
 "eternal" identity.  (Strings are defined as values this way despite
 also being objects.)
 
-(Because Perl 6 uses a false C<.id> to signify a non-instantiated prototype,
-all instances should arrange to return a C<.id> that boolifies to true.)
+(Because Perl 6 uses a false C<.valid> to signify a non-instantiated prototype,
+all instances should arrange to return a C<.valid> that boolifies to true.)
 
 Two values are never equivalent unless they are of exactly the same type.  By
 contrast, C<eq> always coerces to string, while C<==> always coerces to

Modified: doc/trunk/design/syn/S04.pod
==============================================================================
--- doc/trunk/design/syn/S04.pod	(original)
+++ doc/trunk/design/syn/S04.pod	Sun Jul 16 18:58:53 2006
@@ -12,9 +12,9 @@
 
   Maintainer: Larry Wall <larry@wall.org>
   Date: 19 Aug 2004
-  Last Modified: 3 July 2006
+  Last Modified: 16 July 2006
   Number: 4
-  Version: 26
+  Version: 27
 
 This document summarizes Apocalypse 4, which covers the block and
 statement syntax of Perl.
@@ -540,7 +540,7 @@
 C<Failure> objects, which refers to an unthrown C<Exception> object in
 C<$!> and knows whether it has been handled or not.
 
-If you test a C<Failure> for C<.id>, C<.defined> or C<.true>, it causes
+If you test a C<Failure> for C<.valid>, C<.defined> or C<.true>, it causes
 C<$!> to mark the exception as I<handled>, and acts as a harmless C<Undef>
 value thereafter.  Any other use of the C<Failure> will throw its associated
 exception immediately.

Modified: doc/trunk/design/syn/S06.pod
==============================================================================
--- doc/trunk/design/syn/S06.pod	(original)
+++ doc/trunk/design/syn/S06.pod	Sun Jul 16 18:58:53 2006
@@ -13,9 +13,9 @@
 
   Maintainer: Larry Wall <larry@wall.org>
   Date: 21 Mar 2003
-  Last Modified: 1 July 2006
+  Last Modified: 16 July 2006
   Number: 6
-  Version: 39
+  Version: 40
 
 
 This document summarizes Apocalypse 6, which covers subroutines and the
@@ -1337,9 +1337,10 @@
 
 =head2 Undefined types
 
-These can behave as values or objects of any class, but always return a
-C<.id> of 0.  One can create them with the built-in C<undef> and C<fail>
-functions.  (See S02 for how failures are handled.)
+These can behave as values or objects of any class, but always return
+a C<.valid> that evaluates to false.  One can create them with the
+built-in C<undef> and C<fail> functions.  (See S02 for how failures
+are handled.)
 
     Undef       Undefined (can serve as a prototype object of any class)
     Whatever    Wildcard (like undef, but subject to do-what-I-mean via MMD)
@@ -1371,7 +1372,7 @@
 
 =head2 Mutable types
 
-Objects with these types have distinct C<.id> values.
+Objects with these types have distinct C<.valid> values.
 
     Array       Perl array
     Hash        Perl hash
@@ -1954,10 +1955,10 @@
 
     class LoudArray is Array {
         method TEMP {
-            print "Replacing $.id() at {caller.location}\n";
+            print "Replacing $.valid() at {caller.location}\n";
             my $restorer = $.SUPER::TEMP();
             return { 
-                print "Restoring $.id() at {caller.location}\n";
+                print "Restoring $.valid() at {caller.location}\n";
                 $restorer();
             };
         }
@@ -2003,7 +2004,7 @@
     sub thermo ($t) {...}   # set temperature in Celsius, returns old temp
 
     # Add a wrapper to convert from Fahrenheit...
-    $id = &thermo.wrap( { call( ($^t-32)/1.8 ) } );
+    $handle = &thermo.wrap( { call( ($^t-32)/1.8 ) } );
 
 The call to C<.wrap> replaces the original C<Routine> with the C<Code>
 argument, and arranges that the call to C<call> invokes the previous
@@ -2013,13 +2014,13 @@
     &old_thermo := &thermo;
     &thermo := sub ($t) { old_thermo( ($t-32)/1.8 ) }
 
-Except that C<&thermo> is mutated in-place, so C<&thermo.id> stays the same
+Except that C<&thermo> is mutated in-place, so C<&thermo.valid> stays the same
 after the C<.wrap>.
 
-The call to C<.wrap> returns a unique identifier that can later be passed to
+The call to C<.wrap> returns a unique handle that can later be passed to
 the C<.unwrap> method, to undo the wrapping:
 
-    &thermo.unwrap($id);
+    &thermo.unwrap($handle);
 
 This does not affect any other wrappings placed to the routine.
 

• [svn:perl6-synopsis] r10250 - doc/trunk/design/syn by larry