Fix miscellaneous typos

4 files changed, 21 insertions, 22 deletions

diff --git a/pod/perldata.pod b/pod/perldata.pod
index 90ac535e1c..4b6e433515 100644
--- a/pod/perldata.pod
+++ b/pod/perldata.pod
@@ -121,7 +121,7 @@ Scalars aren't necessarily one thing or another.  There's no place to
 declare a scalar variable to be of type "string", or of type "number", or
 type "filehandle", or anything else.  Perl is a contextually polymorphic
 language whose scalars can be strings, numbers, or references (which
-includes objects).  While strings and numbers are considered the pretty
+includes objects).  While strings and numbers are considered pretty
 much same thing for nearly all purposes, references are strongly-typed
 uncastable pointers with built-in reference-counting and destructor
 invocation.
@@ -189,7 +189,7 @@ So in general you can just assume that
 
     scalar(@whatever) == $#whatever + 1;
 
-Some programmer choose to use an explcit conversion so nothing's
+Some programmers choose to use an explicit conversion so nothing's
 left to doubt:
 
     $element_count = scalar(@whatever);
@@ -311,9 +311,8 @@ quotes you use determines the treatment of the text, just as in regular
 quoting.  An unquoted identifier works like double quotes.  There must
 be no space between the C<E<lt>E<lt>> and the identifier.  (If you put a space it
 will be treated as a null identifier, which is valid, and matches the
-first blank line--see the Merry Christmas example below.)  The terminating
-string must appear by itself (unquoted and with no surrounding
-whitespace) on the terminating line.
+first blank line.)  The terminating string must appear by itself 
+(unquoted and with no surrounding whitespace) on the terminating line.
 
 	print <<EOF;	
     The price is $Price.
@@ -334,7 +333,7 @@ whitespace) on the terminating line.
     I said bar.
     bar
 
-	myfunc(<<"THIS", 23, <<'THAT'');
+	myfunc(<<"THIS", 23, <<'THAT');
     Here's a line
     or two.
     THIS
diff --git a/pod/perlmod.pod b/pod/perlmod.pod
index 7a8431b15b..80a4036246 100644
--- a/pod/perlmod.pod
+++ b/pod/perlmod.pod
@@ -747,8 +747,8 @@ Generally you can delete the "eq 'FOO'" part with no harm at all.
 Let the objects look after themselves! Generally, avoid hardwired
 class names as far as possible.
 
-Avoid $r->Class::func() where using @ISA=qw(... Class ...) and
-$r->func() would work (see perlbot man page for more details).
+Avoid $r-E<gt>Class::func() where using @ISA=qw(... Class ...) and
+$r-E<gt>func() would work (see perlbot man page for more details).
 
 Use autosplit so little used or newly added functions won't be a
 burden to programs which don't use them. Add test functions to
@@ -798,7 +798,7 @@ or nature of a variable. For example:
  $no_caps_here    function scope my() or local() variables
 
 Function and method names seem to work best as all lowercase.
-E.g., $obj->as_string().
+E.g., $obj-E<gt>as_string().
 
 You can use a leading underscore to indicate that a variable or
 function should not be used outside the package that defined it.
@@ -814,7 +814,7 @@ export try to use @EXPORT_OK in preference to @EXPORT and avoid
 short or common names to reduce the risk of name clashes.
 
 Generally anything not exported is still accessible from outside the
-module using the ModuleName::item_name (or $blessed_ref->method)
+module using the ModuleName::item_name (or $blessed_ref-E<gt>method)
 syntax.  By convention you can use a leading underscore on names to
 informally indicate that they are 'internal' and not for public use.
 
diff --git a/pod/perlobj.pod b/pod/perlobj.pod
index 59c6f1244c..81c6c96246 100644
--- a/pod/perlobj.pod
+++ b/pod/perlobj.pod
@@ -76,8 +76,8 @@ so that your constructors may be inherited:
 	return $self;
     }
 
-Or if you expect people to call not just C<CLASS->new()> but also
-C<$obj->new()>, then use something like this.  The initialize()
+Or if you expect people to call not just C<CLASS-E<gt>new()> but also
+C<$obj-E<gt>new()>, then use something like this.  The initialize()
 method used will be of whatever $class we blessed the 
 object into:
 
@@ -203,7 +203,7 @@ indirect object slot:
 
     display {find Critter "Fred"} 'Height', 'Weight';
 
-For C++ fans, there's also a syntax using -> notation that does exactly
+For C++ fans, there's also a syntax using -E<gt> notation that does exactly
 the same thing.  The parentheses are required if there are any arguments.
 
     $fred = Critter->find("Fred");
@@ -287,7 +287,7 @@ automatically when the current object is freed.
 
 An indirect object is limited to a name, a scalar variable, or a block,
 because it would have to do too much lookahead otherwise, just like any
-other postfix dereference in the language.  The left side of -> is not so
+other postfix dereference in the language.  The left side of -E<gt> is not so
 limited, because it's an infix operator, not a postfix operator.  
 
 That means that below, A and B are equivalent to each other, and C and D
diff --git a/pod/perlop.pod b/pod/perlop.pod
index 810cff324d..483a686ebb 100644
--- a/pod/perlop.pod
+++ b/pod/perlop.pod
@@ -384,7 +384,7 @@ As a list operator:
     @foo = @foo[$#foo-4 .. $#foo];	# slice last 5 items
 
 The range operator (in a list context) makes use of the magical
-autoincrement algorithm if the operaands are strings.  You
+autoincrement algorithm if the operands are strings.  You
 can say
 
     @alphabet = ('A' .. 'Z');
@@ -960,10 +960,10 @@ list consisting of all the input lines is returned, one line per list
 element.  It's easy to make a I<LARGE> data space this way, so use with
 care.
 
-The null filehandle <> is special and can be used to emulate the
-behavior of B<sed> and B<awk>.  Input from <> comes either from
+The null filehandle E<lt>E<gt> is special and can be used to emulate the
+behavior of B<sed> and B<awk>.  Input from E<lt>E<gt> comes either from
 standard input, or from each file listed on the command line.  Here's
-how it works: the first time <> is evaluated, the @ARGV array is
+how it works: the first time E<lt>E<gt> is evaluated, the @ARGV array is
 checked, and if it is null, C<$ARGV[0]> is set to "-", which when opened
 gives you standard input.  The @ARGV array is then processed as a list
 of filenames.  The loop
@@ -984,11 +984,11 @@ is equivalent to the following Perl-like pseudo code:
 
 except that it isn't so cumbersome to say, and will actually work.  It
 really does shift array @ARGV and put the current filename into variable
-$ARGV.  It also uses filehandle I<ARGV> internally--<> is just a synonym
+$ARGV.  It also uses filehandle I<ARGV> internally--E<lt>E<gt> is just a synonym
 for <ARGV>, which is magical.  (The pseudo code above doesn't work
 because it treats <ARGV> as non-magical.)
 
-You can modify @ARGV before the first <> as long as the array ends up
+You can modify @ARGV before the first E<lt>E<gt> as long as the array ends up
 containing the list of filenames you really want.  Line numbers (C<$.>)
 continue as if the input were one big happy file.  (But see example
 under eof() for how to reset line numbers on each file.)
@@ -1008,7 +1008,7 @@ Getopts modules or put a loop on the front like this:
 	...		# code for each line
     }
 
-The <> symbol will return FALSE only once.  If you call it again after
+The E<lt>E<gt> symbol will return FALSE only once.  If you call it again after
 this it will assume you are processing another @ARGV list, and if you
 haven't set @ARGV, will input from STDIN.
 
@@ -1027,7 +1027,7 @@ $ interpretation is done first, but you can't say C<E<lt>$fooE<gt>>
 because that's an indirect filehandle as explained in the previous
 paragraph.  In older version of Perl, programmers would insert curly
 brackets to force interpretation as a filename glob: C<E<lt>${foo}E<gt>>.
-These days, it's consdired cleaner to call the internal function directly
+These days, it's considered cleaner to call the internal function directly
 as C<glob($foo)>, which is probably the right way to have done it in the
 first place.)  Example: