--- AnyEvent/lib/AnyEvent.pm	2012/03/27 16:21:11	1.398
+++ AnyEvent/lib/AnyEvent.pm	2013/05/18 02:59:42	1.412
@@ -273,7 +273,7 @@
 
    my $w = AnyEvent->timer (after => 0.5, interval => 1, cb => sub {
       warn "timeout\n";
-   };
+   });
 
 =head3 TIMING ISSUES
 
@@ -765,6 +765,10 @@
 
    $cv->end;
 
+   ...
+
+   my $results = $cv->recv;
+
 This code fragment supposedly pings a number of hosts and calls
 C<send> after results for all then have have been gathered - in any
 order. To achieve this, the code issues a call to C<begin> when it starts
@@ -809,11 +813,15 @@
 in scalar context only the first one will be returned.
 
 Note that doing a blocking wait in a callback is not supported by any
-event loop, that is, recursive invocation of a blocking C<< ->recv
->> is not allowed, and the C<recv> call will C<croak> if such a
-condition is detected. This condition can be slightly loosened by using
-L<Coro::AnyEvent>, which allows you to do a blocking C<< ->recv >> from
-any thread that doesn't run the event loop itself.
+event loop, that is, recursive invocation of a blocking C<< ->recv >> is
+not allowed and the C<recv> call will C<croak> if such a condition is
+detected. This requirement can be dropped by relying on L<Coro::AnyEvent>
+, which allows you to do a blocking C<< ->recv >> from any thread
+that doesn't run the event loop itself. L<Coro::AnyEvent> is loaded
+automatically when L<Coro> is used with L<AnyEvent>, so code does not need
+to do anything special to take advantage of that: any code that would
+normally block your program because it calls C<recv>, be executed in an
+C<async> thread instead without blocking other threads.
 
 Not all event models support a blocking wait - some die in that case
 (programs might want to do that to stay interactive), so I<if you are
@@ -1141,24 +1149,24 @@
 
 =over 4
 
-=item L<AnyEvent::Util>
+=item L<AnyEvent::Util> (part of the AnyEvent distribution)
 
 Contains various utility functions that replace often-used blocking
 functions such as C<inet_aton> with event/callback-based versions.
 
-=item L<AnyEvent::Socket>
+=item L<AnyEvent::Socket> (part of the AnyEvent distribution)
 
 Provides various utility functions for (internet protocol) sockets,
 addresses and name resolution. Also functions to create non-blocking tcp
 connections or tcp servers, with IPv6 and SRV record support and more.
 
-=item L<AnyEvent::Handle>
+=item L<AnyEvent::Handle> (part of the AnyEvent distribution)
 
 Provide read and write buffers, manages watchers for reads and writes,
 supports raw and formatted I/O, I/O queued and fully transparent and
 non-blocking SSL/TLS (via L<AnyEvent::TLS>).
 
-=item L<AnyEvent::DNS>
+=item L<AnyEvent::DNS> (part of the AnyEvent distribution)
 
 Provides rich asynchronous DNS resolver capabilities.
 
@@ -1168,7 +1176,7 @@
 the curious, IGS is the International Go Server and FCP is the Freenet
 Client Protocol).
 
-=item L<AnyEvent::AIO>
+=item L<AnyEvent::AIO> (part of the AnyEvent distribution)
 
 Truly asynchronous (as opposed to non-blocking) I/O, should be in the
 toolbox of every event programmer. AnyEvent::AIO transparently fuses
@@ -1236,7 +1244,7 @@
 
 use Carp ();
 
-our $VERSION = '6.14';
+our $VERSION = '7.04';
 our $MODEL;
 our @ISA;
 our @REGISTRY;
@@ -1398,7 +1406,7 @@
    # the author knows about the problems and what it does to AnyEvent as a whole
    # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent
    # anyway.
-   AnyEvent::log fatal => "AnyEvent: IO::Async::Loop::AnyEvent detected - that module is broken by\n"
+   AnyEvent::log fatal => "IO::Async::Loop::AnyEvent detected - that module is broken by\n"
                         . "design, abuses internals and breaks AnyEvent - will not continue."
       if exists $INC{"IO/Async/Loop/AnyEvent.pm"};
 
@@ -1419,10 +1427,10 @@
       my $model = $1;
       $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;
       if (eval "require $model") {
-         AnyEvent::log 7 => "loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
+         AnyEvent::log 7 => "Loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
          $MODEL = $model;
       } else {
-         AnyEvent::log 4 => "unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
+         AnyEvent::log 4 => "Unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
       }
    }
 
@@ -1432,11 +1440,11 @@
          my ($package, $model) = @$_;
          if (${"$package\::VERSION"} > 0) {
             if (eval "require $model") {
-               AnyEvent::log 7 => "autodetected model '$model', using it.";
+               AnyEvent::log 7 => "Autodetected model '$model', using it.";
                $MODEL = $model;
                last;
             } else {
-               AnyEvent::log 8 => "detected event loop $package, but cannot load '$model', skipping: $@";
+               AnyEvent::log 8 => "Detected event loop $package, but cannot load '$model', skipping: $@";
             }
          }
       }
@@ -1450,14 +1458,14 @@
                and ${"$package\::VERSION"} > 0
                and eval "require $model"
             ) {
-               AnyEvent::log 7 => "autoloaded model '$model', using it.";
+               AnyEvent::log 7 => "Autoloaded model '$model', using it.";
                $MODEL = $model;
                last;
             }
          }
 
          $MODEL
-           or AnyEvent::log fatal => "AnyEvent: backend autodetection failed - did you properly install AnyEvent?";
+           or AnyEvent::log fatal => "Backend autodetection failed - did you properly install AnyEvent?";
       }
    }
 
@@ -1614,13 +1622,13 @@
          *time     = sub { Time::HiRes::time () };
          *AE::time = \&    Time::HiRes::time     ;
          *now      = \&time;
-         AnyEvent::log 8 => "AnyEvent: using Time::HiRes for sub-second timing accuracy.";
+         AnyEvent::log 8 => "using Time::HiRes for sub-second timing accuracy.";
          # if (eval "use POSIX (); (POSIX::times())...
       } else {
          *time     = sub   { CORE::time };
          *AE::time = sub (){ CORE::time };
          *now      = \&time;
-         AnyEvent::log 3 => "using built-in time(), WARNING, no sub-second resolution!";
+         AnyEvent::log 3 => "Using built-in time(), no sub-second resolution!";
       }
    };
    die if $@;
@@ -1724,13 +1732,13 @@
    eval q{ # poor man's autoloading {}
       # probe for availability of Async::Interrupt 
       if (_have_async_interrupt) {
-         AnyEvent::log 8 => "using Async::Interrupt for race-free signal handling.";
+         AnyEvent::log 8 => "Using Async::Interrupt for race-free signal handling.";
 
          $SIGPIPE_R = new Async::Interrupt::EventPipe;
          $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
 
       } else {
-         AnyEvent::log 8 => "using emulated perl signal handling with latency timer.";
+         AnyEvent::log 8 => "Using emulated perl signal handling with latency timer.";
 
          if (AnyEvent::WIN32) {
             require AnyEvent::Util;
@@ -2180,6 +2188,14 @@
 
    PERL_ANYEVENT_MODEL=Perl perl ...
 
+=item C<PERL_ANYEVENT_IO_MODEL>
+
+The current file I/O model - see L<AnyEvent::IO> for more info.
+
+At the moment, only C<Perl> (small, pure-perl, synchronous) and
+C<IOAIO> (truly asynchronous) are supported. The default is C<IOAIO> if
+L<AnyEvent::AIO> can be loaded, otherwise it is C<Perl>.
+
 =item C<PERL_ANYEVENT_PROTOCOLS>
 
 Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences
@@ -2915,6 +2931,16 @@
 pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to
 try to use a monotonic clock for timing stability.
 
+=item L<AnyEvent::AIO> (and L<IO::AIO>)
+
+The default implementation of L<AnyEvent::IO> is to do I/O synchronously,
+stopping programs while they access the disk, which is fine for a lot of
+programs.
+
+Installing AnyEvent::AIO (and its IO::AIO dependency) makes it switch to
+a true asynchronous implementation, so event processing can continue even
+while waiting for disk I/O.
+
 =back
 
 
@@ -3007,6 +3033,8 @@
 Non-blocking handles, pipes, stream sockets, TCP clients and
 servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
 
+Asynchronous File I/O: L<AnyEvent::IO>.
+
 Asynchronous DNS: L<AnyEvent::DNS>.
 
 Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>.
@@ -3018,7 +3046,7 @@
 =head1 AUTHOR
 
    Marc Lehmann <schmorp@schmorp.de>
-   http://home.schmorp.de/
+   http://anyevent.schmorp.de
 
 =cut