This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[perl #22011] [PATCH] pod/perlmod.pod (v5.8.0)
[perl5.git] / pod / perlmod.pod
index ddcbe47..a216457 100644 (file)
@@ -33,7 +33,7 @@ preferred delimiter, in part because it's more readable to humans, and
 in part because it's more readable to B<emacs> macros.  It also makes C++
 programmers feel like they know what's going on--as opposed to using the
 single quote as separator, which was there to make Ada programmers feel
-like they knew what's going on.  Because the old-fashioned syntax is still
+like they knew what was going on.  Because the old-fashioned syntax is still
 supported for backwards compatibility, if you try to use a string like
 C<"This is $owner's house">, you'll be accessing C<$owner::s>; that is,
 the $s variable in package C<owner>, which is probably not what you meant.
@@ -45,7 +45,7 @@ name lookups, however.  There are no relative packages: all symbols
 are either local to the current package, or must be fully qualified
 from the outer package name down.  For instance, there is nowhere
 within package C<OUTER> that C<$INNER::var> refers to
-C<$OUTER::INNER::var>.  It would treat package C<INNER> as a totally
+C<$OUTER::INNER::var>.  C<INNER> refers to a totally
 separate global package.
 
 Only identifiers starting with letters (or underscore) are stored
@@ -53,7 +53,7 @@ in a package's symbol table.  All other symbols are kept in package
 C<main>, including all punctuation variables, like $_.  In addition,
 when unqualified, the identifiers STDIN, STDOUT, STDERR, ARGV,
 ARGVOUT, ENV, INC, and SIG are forced to be in package C<main>,
-even when used for other purposes than their built-in one.  If you
+even when used for other purposes than their built-in ones.  If you
 have a package called C<m>, C<s>, or C<y>, then you can't use the
 qualified form of an identifier because it would be instead interpreted
 as a pattern match, a substitution, or a transliteration.
@@ -77,7 +77,7 @@ expressions in the context of the C<main> package (or wherever you came
 from).  See L<perldebug>.
 
 The special symbol C<__PACKAGE__> contains the current package, but cannot
-(easily) be used to construct variables.
+(easily) be used to construct variable names.
 
 See L<perlsub> for other scoping issues related to my() and local(),
 and L<perlref> regarding closures.
@@ -153,7 +153,7 @@ it was exported:
     @EXPORT = qw($FOO); # Usual form, can't be localized
     @EXPORT = qw(*FOO); # Can be localized
 
-You can work around the first case by using the fully qualified name 
+You can work around the first case by using the fully qualified name
 (C<$Package::FOO>) where you need a local value, or by overriding it
 by saying C<*FOO = *Package::FOO> in your script.
 
@@ -185,7 +185,7 @@ Another use of symbol tables is for making "constant" scalars.
 Now you cannot alter C<$PI>, which is probably a good thing all in all.
 This isn't the same as a constant subroutine, which is subject to
 optimization at compile-time.  A constant subroutine is one prototyped
-to take no arguments and to return a constant expression.  See 
+to take no arguments and to return a constant expression.  See
 L<perlsub> for details on these.  The C<use constant> pragma is a
 convenient shorthand for these.
 
@@ -304,7 +304,7 @@ is not.
 There is no special class syntax in Perl, but a package may act
 as a class if it provides subroutines to act as methods.  Such a
 package may also derive some of its methods from another class (package)
-by listing the other package name(s) in its global @ISA array (which 
+by listing the other package name(s) in its global @ISA array (which
 must be a package global, not a lexical).
 
 For more on this, see L<perltoot> and L<perlobj>.
@@ -312,10 +312,10 @@ For more on this, see L<perltoot> and L<perlobj>.
 =head2 Perl Modules
 
 A module is just a set of related functions in a library file, i.e.,
-a Perl package with the same name as the file.  It is specifically 
+a Perl package with the same name as the file.  It is specifically
 designed to be reusable by other modules or programs.  It may do this
 by providing a mechanism for exporting some of its symbols into the
-symbol table of any package using it.  Or it may function as a class
+symbol table of any package using it, or it may function as a class
 definition and make its semantics available implicitly through
 method calls on the class and its objects, without explicitly
 exporting anything.  Or it can do a little of both.
@@ -430,7 +430,7 @@ if you're a classicist).
 The two statements:
 
     require SomeModule;
-    require "SomeModule.pm";           
+    require "SomeModule.pm";
 
 differ from each other in two ways.  In the first case, any double
 colons in the module name, such as C<Some::Module>, are translated
@@ -462,7 +462,7 @@ In general, C<use Module ()> is recommended over C<require Module>,
 because it determines module availability at compile time, not in the
 middle of your program's execution.  An exception would be if two modules
 each tried to C<use> each other, and each also called a function from
-that other module.  In that case, it's easy to use C<require>s instead.
+that other module.  In that case, it's easy to use C<require> instead.
 
 Perl packages may be nested inside other package names, so we can have
 package names containing C<::>.  But if we used that package name
@@ -482,14 +482,15 @@ autoloading, the user can say just C<use POSIX> to get it all.
 
 =head2 Making your module threadsafe
 
-Perl has since 5.6.0 support for a new type of threads called
-interpreter threads. These threads can be used explicitly and implicitly.
+Since 5.6.0, Perl has had support for a new type of threads called
+interpreter threads (ithreads). These threads can be used explicitly
+and implicitly.
 
 Ithreads work by cloning the data tree so that no data is shared
-between different threads. These threads can be used using the threads
+between different threads. These threads can be used by using the C<threads>
 module or by doing fork() on win32 (fake fork() support). When a
 thread is cloned all Perl data is cloned, however non-Perl data cannot
-be cloned automatically.  Perl after 5.7.2 has support for the C<CLONE> 
+be cloned automatically.  Perl after 5.7.2 has support for the C<CLONE>
 special subroutine .  In C<CLONE> you can do whatever you need to do,
 like for example handle the cloning of non-Perl data, if necessary.
 C<CLONE> will be executed once for every package that has it defined