[ViewVC] Diff of: cvs/cvsroot/Coro/README

Comparing cvsroot/Coro/README (file contents):
Revision 1.14 by root, Sat May 10 22:32:40 2008 UTC vs.
Revision 1.17 by root, Wed Nov 5 15:38:10 2008 UTC

       cede; # yield to coroutine
       print "3\n";
       cede; # and again
   # use locking
+      use Coro::Semaphore;
       my $lock = new Coro::Semaphore;
       my $locked;
   $lock->down;
       $locked = 1;
     $Coro::main
         This variable stores the coroutine object that represents the main
         program. While you cna "ready" it and do most other things you can
         do to coroutines, it is mainly useful to compare again
-        $Coro::current, to see wether you are running in the main program or
+        $Coro::current, to see whether you are running in the main program
-        not.
+        or not.
     $Coro::current
         The coroutine object representing the current coroutine (the last
         coroutine that the Coro scheduler switched to). The initial value is
         $main (of course).
         call terminate or join on it (although you are allowed to), and you
         get a coroutine that might have executed other code already (which
         can be good or bad :).
         On the plus side, this function is faster than creating (and
-        destroying) a completely new coroutine, so if you need a lot of
+        destroying) a completly new coroutine, so if you need a lot of
         generic coroutines in quick successsion, use "async_pool", not
         "async".
         The code block is executed in an "eval" context and a warning will
         be issued in case of an exception instead of terminating the
         The priority will be reset to 0 after each run, tracing will be
         disabled, the description will be reset and the default output
         filehandle gets restored, so you can change all these. Otherwise the
         coroutine will be re-used "as-is": most notably if you change other
-        per-coroutine global stuff such as $/ you *must needs* to revert
+        per-coroutine global stuff such as $/ you *must needs* revert that
-        that change, which is most simply done by using local as in: " local
+        change, which is most simply done by using local as in: "local $/".
-        $/ ".
-        The pool size is limited to 8 idle coroutines (this can be adjusted
+        The idle pool size is limited to 8 idle coroutines (this can be
-        by changing $Coro::POOL_SIZE), and there can be as many non-idle
+        adjusted by changing $Coro::POOL_SIZE), but there can be as many
-        coros as required.
+        non-idle coros as required.
         If you are concerned about pooled coroutines growing a lot because a
         single "async_pool" used a lot of stackspace you can e.g.
         "async_pool { terminate }" once per second or so to slowly replenish
         the pool. In addition to that, when the stacks used by a handler
         This makes "schedule" *the* generic method to use to block the
         current coroutine and wait for events: first you remember the
         current coroutine in a variable, then arrange for some callback of
         yours to call "->ready" on that once some event happens, and last
         you call "schedule" to put yourself to sleep. Note that a lot of
-        things can wake your coroutine up, so you need to check wether the
+        things can wake your coroutine up, so you need to check whether the
         event indeed happened, e.g. by storing the status in a variable.
         The canonical way to wait on external events is this:
            {
         Kills/terminates/cancels all coroutines except the currently running
         one. This is useful after a fork, either in the child or the parent,
         as usually only one of them should inherit the running coroutines.
         Note that while this will try to free some of the main programs
-        resources, you cnanot free all of them, so if a coroutine that is
+        resources, you cannot free all of them, so if a coroutine that is
         not the main program calls this function, there will be some
         one-time resource leak.
   COROUTINE METHODS
     These are the methods you can call on coroutine objects (or to create
         automatically once all the coroutines of higher priority and all
         coroutines of the same priority that were put into the ready queue
         earlier have been resumed.
     $is_ready = $coroutine->is_ready
-        Return wether the coroutine is currently the ready queue or not,
+        Return whether the coroutine is currently the ready queue or not,
     $coroutine->cancel (arg...)
         Terminates the given coroutine and makes it return the given
         arguments as status (default: the empty list). Never returns if the
         coroutine is the current coroutine.
+    $coroutine->throw ([$scalar])
+        If $throw is specified and defined, it will be thrown as an
+        exception inside the coroutine at the next convenient point in time
+        (usually after it gains control at the next schedule/transfer/cede).
+        Otherwise clears the exception object.
+        The exception object will be thrown "as is" with the specified
+        scalar in $@, i.e. if it is a string, no line number or newline will
+        be appended (unlike with "die").
+        This can be used as a softer means than "cancel" to ask a coroutine
+        to end itself, although there is no guarantee that the exception
+        will lead to termination, and if the exception isn't caught it might
+        well end the whole program.
+        You might also think of "throw" as being the moral equivalent of
+        "kill"ing a coroutine with a signal (in this case, a scalar).
     $coroutine->join
         Wait until the coroutine terminates and return any values given to
         the "terminate" or "cancel" functions. "join" can be called
         concurrently from multiple coroutines, and all will be resumed and
         this coroutine. This is just a free-form string you can associate
         with a coroutine.
         This method simply sets the "$coroutine->{desc}" member to the given
         string. You can modify this member directly if you wish.
-    $coroutine->throw ([$scalar])
-        If $throw is specified and defined, it will be thrown as an
-        exception inside the coroutine at the next convinient point in time
-        (usually after it gains control at the next schedule/transfer/cede).
-        Otherwise clears the exception object.
-        The exception object will be thrown "as is" with the specified
-        scalar in $@, i.e. if it is a string, no line number or newline will
-        be appended (unlike with "die").
-        This can be used as a softer means than "cancel" to ask a coroutine
-        to end itself, although there is no guarentee that the exception
-        will lead to termination, and if the exception isn't caught it might
-        well end the whole program.
   GLOBAL FUNCTIONS
     Coro::nready
         Returns the number of coroutines that are currently in the ready
         state, i.e. that can be switched to by calling "schedule" directory

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing cvsroot/Coro/README (file contents): Revision 1.14 by root, Sat May 10 22:32:40 2008 UTC vs. Revision 1.17 by root, Wed Nov 5 15:38:10 2008 UTC

Diff Legend

Comparing cvsroot/Coro/README (file contents):
Revision 1.14 by root, Sat May 10 22:32:40 2008 UTC vs.
Revision 1.17 by root, Wed Nov 5 15:38:10 2008 UTC