NAME

    Ryu::Async - use Ryu with IO::Async

SYNOPSIS

     #!/usr/bin/env perl
     use strict;
     use warnings;
     use IO::Async::Loop;
     use Ryu::Async;
     # This will generate a lot of output, but is useful
     # for demonstrating lifecycles. Drop this to 'info' or
     # 'debug' to make it more realistic.
     use Log::Any::Adapter qw(Stdout), log_level => 'trace';
     #
     my $loop = IO::Async::Loop->new;
     $loop->add(
            my $ryu = Ryu::Async->new
     );
     {
            my $timer = $ryu->timer(
                    interval => 0.10,
            )->take(10)
             ->each(sub { print "tick\n" });
            warn $timer->describe;
            $timer->get;
     }

DESCRIPTION

    This is an IO::Async::Notifier subclass for interacting with Ryu.

Interaction with Ryu

    On load, this module will provide a "$FUTURE_FACTORY" in Ryu::Source
    which assigns Future instances from IO::Async::Loop.

    You can override this behaviour by doing this instead:

     BEGIN {
      require Ryu::Source;
      local $Ryu::Source::FUTURE_FACTORY = sub { };
      require Ryu::Async;
     }

    to ensure the original factory function is preserved.

METHODS

 from

    Creates a new Ryu::Source from a thing.

    The exact details of this are likely to change in future, but a few
    things that are expected to work:

     $ryu->from($io_async_stream_instance)
         ->by_line
         ->each(sub { print "Line: $_\n" });
     $ryu->from([1..1000])
         ->sum
         ->each(sub { print "Total was $_\n" });

 from_stream

    Create a new Ryu::Source from an IO::Async::Stream instance.

    Note that a stream which is not already attached to an
    IO::Async::Notifier will be added as a child of this instance.

 to_stream

    Provides a Ryu::Sink that will send data to an IO::Async::Stream
    instance.

    Requires the IO::Async::Stream and will return a new Ryu::Sink
    instance.

 stdin

    Create a new Ryu::Source that wraps STDIN.

    As with other IO::Async::Stream wrappers, this will emit data as soon
    as it's available, as raw bytes.

    Use "by_line" in Ryu::Source and "decode" in Ryu::Source to split into
    lines and/or decode from UTF-8.

 stdout

    Returns a new Ryu::Sink that wraps STDOUT.

 stderr

    Returns a new Ryu::Sink that wraps STDERR.

 timer

    Provides a Ryu::Source which emits an empty string at selected
    intervals.

    Takes the following named parameters:

      * interval - how often to trigger the timer, in seconds (fractional
      values allowed)

      * reschedule - type of rescheduling to use, can be soft, hard or
      drift as documented in IO::Async::Timer::Periodic

    Example:

     $ryu->timer(interval => 1, reschedule => 'hard')
         ->combine_latest(...)

 run

    Creates an IO::Async::Process.

 source

    Returns a new Ryu::Source instance.

 udp_client

    Creates a new UDP client.

    This provides a sink for "outgoing" in Ryu::Async::Client packets, and
    a source for "incoming" in Ryu::Async::Client responses.

      * uri - an optional URI of the form udp://host:port

      * host - which host to listen on, defaults to 0.0.0.0

      * port - the port to listen on

    Returns a Ryu::Async::Client instance.

 udp_server

 tcp_server

    Creates a listening TCP socket, and provides a Ryu::Async::Server
    instance which will emit a new event every time a client connects.

 sink

    Returns a new Ryu::Sink.

    The label will default to the calling package/class and method, with
    some truncation rules:

      * A Net::Async:: prefix will be replaced by Na.

      * A Web::Async:: prefix will be replaced by Wa.

      * A Database::Async:: prefix will be replaced by Da.

      * A IO::Async:: prefix will be replaced by Ia.

      * A Tickit::Async:: prefix will be replaced by Ta.

      * A Tickit::Widget:: prefix will be replaced by TW.

    This list of truncations is subject to change, so please don't rely on
    any of these in string matches or similar - better to set your own
    label if you need consistency.

SEE ALSO

      * Ryu

      * IO::Async

AUTHOR

    Tom Molesworth TEAM@cpan.org with contributions from Eyad Arnabeh.

LICENSE

    Copyright Tom Molesworth 2011-2021. Licensed under the same terms as
    Perl itself.

