Description: Fix several typos in Thread.pm's docs
Author: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
--- a/Thread.pm
+++ b/Thread.pm
@@ -245,7 +245,7 @@
     local $\ = "\n";
 
     while (my $action = $iqueue->dequeue) {
-        DEBUG and warn threads->self->tid, ": recieved action";
+        DEBUG and warn threads->self->tid, ": received action";
         $semaphore->down;
 
 #       lock $action;
@@ -305,15 +305,15 @@
                my ($kernel, $heap) = @_[ KERNEL, HEAP ];
 
                # We are inside the component session
-               $kernel->yield(run => @arguements);
+               $kernel->yield(run => @arguments);
 
-               $kernel->post(ThreadPool => run => @arguements);
+               $kernel->post(ThreadPool => run => @arguments);
           },
       }
     );
 
  sub thread_entry_point {
-    my (@arguements) = @_;
+    my (@arguments) = @_;
 
     return 1;
  }
@@ -335,10 +335,10 @@
 =head1 RATIONALE
 
 Cooperative Co-routine type programming isn't always available.  Some third
-party software (dependant libraries and/or modules) and particular tasks block
+party software (dependent libraries and/or modules) and particular tasks block
 processing weither you like it or not.
 
-Creation of threads is alot of overhead, infact quite a bit more overhead under
+Creation of threads is a lot of overhead, infact quite a bit more overhead under
 the current implementation of ithreads than fork is.  Allocating these
 resources before you need them is an obvious solution to this problem, if you
 create the threads and re-use them, they're around when you need them without
@@ -359,17 +359,17 @@
 
 The new constructor is the only package method available with this package.  It
 creates a POE thread pool session which you describe in the following
-arguements.
+arguments.
 
 =over 4
 
 =item EntryPoint CODE
 
-This arguement describes the entry point of the thread and is required.  In the
+This argument describes the entry point of the thread and is required.  In the
 actual implementation, this is not actually an entry point.  This is instead a
-coderef the thread will call repeatedly.  The arguements of this subroutine
-will be the arguements recieved by the controlling session.  In order to pass
-references as arguements, each reference must be shared (L<threads::shared>).
+coderef the thread will call repeatedly.  The arguments of this subroutine
+will be the arguments received by the controlling session.  In order to pass
+references as arguments, each reference must be shared (L<threads::shared>).
 Filehandles and blessed references cannot be shared.  You will have to
 translate them yourself.  With file handles, you can pass simply the file
 descriptor and reopen it in the child thread.  With blessed references, you can
@@ -377,38 +377,38 @@
 
 =item CallBack CODE
 
-This arguement descirbes the result handler, which is where the captured
+This argument descirbes the result handler, which is where the captured
 results of a threads last execution are sent.  As with EntryPoint subroutine
-arguements, any data structures you wish to pass through return results must be
+arguments, any data structures you wish to pass through return results must be
 explicitly shared (L<threads::shared>).
 
 =item Name ALIAS
 
-This arguement descirbes the default alias your threadpool session is given.
+This argument descirbes the default alias your threadpool session is given.
 
 =item StartThreads INTEGER
 
-This arguement describes the number of threads the component will create during
+This argument describes the number of threads the component will create during
 its "_start" state, or when the POE Session is being started.  This should be a
 number greater than MinFree and less than or equal to MaxFree.
 
 =item MaxThreads INTEGER
 
-This arguement descirbes the maximum number of threads this component will
+This argument descirbes the maximum number of threads this component will
 create for this task.  If the component is assigned more tasks than threads, it
 will place the remaining tasks in an internal FIFO queue and assign them
 threads as they complete their tasks.
 
 =item MinFree INTEGER
 
-This arguement sets the minimum number of free threads to maintain.  When the
+This argument sets the minimum number of free threads to maintain.  When the
 component is assigned a new task, if there are less than this number of threads
 available, it will yield a request to create a new thread at the components
 convience.
 
 =item MaxFree INTEGER
 
-This arguement provides the maximum number of free threads to maintain.  Upon
+This argument provides the maximum number of free threads to maintain.  Upon
 completion of a task, this value is checked.  If there are more free threads
 than this value available, the oldest thread is asked to shut down.