ExtUtils::MakeMaker 6.02 -> 6.03

[perl5.git] / lib / overload.pm

diff --git a/lib/overload.pm b/lib/overload.pm
index 21a4b67..fb1a0d1 100644 (file)
--- a/lib/overload.pm
+++ b/lib/overload.pm
@@ -91,7 +91,7 @@ sub AddrRef {
 }
 
 sub StrVal {
-  (OverloadedStringify($_[0]) or ref($_[0]) eq 'Regexp') ?
+  (ref $_[0] && OverloadedStringify($_[0]) or ref($_[0]) eq 'Regexp') ?
     (AddrRef(shift)) :
     "$_[0]";
 }
@@ -298,7 +298,7 @@ if C<+=> is not overloaded.
 
 =back
 
-B<Warning.>  Due to the presense of assignment versions of operations,
+B<Warning.>  Due to the presence of assignment versions of operations,
 routines which may be called in assignment context may create
 self-referential structures.  Currently Perl will not free self-referential
 structures until cycles are C<explicitly> broken.  You may get problems
@@ -333,9 +333,9 @@ The following symbols can be specified in C<use overload> directive:
     "**", "**=", "<<", "<<=", ">>", ">>=", "x", "x=", ".", ".=",
 
 For these operations a substituted non-assignment variant can be called if
-the assignment variant is not available.  Methods for operations "C<+>",
-"C<->", "C<+=>", and "C<-=>" can be called to automatically generate
-increment and decrement methods.  The operation "C<->" can be used to
+the assignment variant is not available.  Methods for operations C<+>,
+C<->, C<+=>, and C<-=> can be called to automatically generate
+increment and decrement methods.  The operation C<-> can be used to
 autogenerate missing methods for unary minus or C<abs>.
 
 See L<"MAGIC AUTOGENERATION">, L<"Calling Conventions for Mutators"> and
@@ -355,10 +355,10 @@ arrays, C<cmp> is used to compare values subject to C<use overload>.
 
     "&", "^", "|", "neg", "!", "~",
 
-"C<neg>" stands for unary minus.  If the method for C<neg> is not
+C<neg> stands for unary minus.  If the method for C<neg> is not
 specified, it can be autogenerated using the method for
-subtraction. If the method for "C<!>" is not specified, it can be
-autogenerated using the methods for "C<bool>", or "C<\"\">", or "C<0+>".
+subtraction. If the method for C<!> is not specified, it can be
+autogenerated using the methods for C<bool>, or C<"">, or C<0+>.
 
 =item * I<Increment and decrement>
 
@@ -382,11 +382,11 @@ C<0+>.
 
 =item * I<Boolean, string and numeric conversion>
 
-    "bool", "\"\"", "0+",
+    'bool', '""', '0+',
 
 If one or two of these operations are not overloaded, the remaining ones can
 be used instead.  C<bool> is used in the flow control operators
-(like C<while>) and for the ternary "C<?:>" operation.  These functions can
+(like C<while>) and for the ternary C<?:> operation.  These functions can
 return any arbitrary Perl value.  If the corresponding operation for this value
 is overloaded too, that operation will be called again with this value.
 
@@ -404,6 +404,9 @@ glob (which may require a stringification).  The same overloading
 happens both for the I<read-filehandle> syntax C<E<lt>$varE<gt>> and
 I<globbing> syntax C<E<lt>${var}E<gt>>.
 
+B<BUGS> Even in list context, the iterator is currently called only
+once and with scalar context.
+
 =item * I<Dereferencing>
 
     '${}', '@{}', '%{}', '&{}', '*{}'.
@@ -852,7 +855,7 @@ C<$a = $b> values of $a and $b become I<indistinguishable>.
 On the other hand, anyone who has used algebraic notation knows the
 expressive power of the arithmetic metaphor.  Overloading works hard
 to enable this metaphor while preserving the Perlian way as far as
-possible.  Since it is not not possible to freely mix two contradicting
+possible.  Since it is not possible to freely mix two contradicting
 metaphors, overloading allows the arithmetic way to write things I<as
 far as all the mutators are called via overloaded access only>.  The
 way it is done is described in L<Copy Constructor>.
@@ -969,7 +972,7 @@ TIEHASH() method is a scalar reference.
 
 Second, we create a new tied hash each time the hash syntax is used.
 This allows us not to worry about a possibility of a reference loop,
-would would lead to a memory leak.
+which would lead to a memory leak.
 
 Both these problems can be cured.  Say, if we want to overload hash
 dereference on a reference to an object which is I<implemented> as a
@@ -1135,7 +1138,7 @@ which outputs
 and one can inspect the value in debugger using all the possible
 methods.
 
-Something is is still amiss: consider the loop variable $cnt of the
+Something is still amiss: consider the loop variable $cnt of the
 script.  It was a number, not an object.  We cannot make this value of
 type C<symbolic>, since then the loop will not terminate.