TITLE

SUBTITLE

Built-in class for providing built system related information.  Usually accessed
through dynamic variables mixing this role such as the
L«C<$*KERNEL>|/language/variables#Dynamic_variables»,
L«C<$*VM>|/language/variables#Dynamic_variables», or
L«C<$*RAKU>|/language/variables#Dynamic_variables».


head

Instance method returning the "auth" (as in "author" or "authority") of the
object. Returns "unknown" if the "auth" could not be established.


Instance returning a hash with object configuration information. Subject to
change without notice, but can be helpful in environments where only one type of
virtual machine is in use, or to find about the configuration of any other
object that mixes in this role.


Instance method returning the "desc" (as in "description") of the VM object.
Returns a L<C<Str>|/type/Str> type object if the "desc" could not be established.


Instance method returning the name of the object.


Instance method returning the signature of the object. Returns a
L<C<Blob>|/type/Blob> type object if the signature could not be established.


Instance method returning the version of the object as a
L<C<Version>|/type/Version> object. Returns a L<C<Version>|/type/Version> object "unknown" if the
version could not be established.


Instance method returning the name and version of the object.


say $*RAKU.gist; # OUTPUT: «Raku (6.d)␤»


C<$*RAKU> is an object of the L<C<Raku>|/type/Raku> type, which mixes in this role
and thus implements this method.


root

CompUnit::PrecompilationRepository


role CompUnit::PrecompilationRepository


CompUnit::Repository


role CompUnit::Repository


Input/output related routines


role IO


Network socket


role IO::Socket


Scheme for automatically assigning tasks to threads


role Scheduler


Information related to the build system


para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

role Systemic


A Tap is a subscription to a L<C<Supply>|/type/Supply>.


my $s = Supplier.new;
my $tap = $s.Supply.on-close({ say "Tap closed" }).tap(
    -> $v { say "the value is $v" },
    done    => { say "Supply is done" },
    quit    => -> $ex { say "Supply finished with error $ex" },
);


Member variable


class Attribute


Removal of a task from a Scheduler before normal completion


class Cancellation


Thread-safe queue for sending values from producers to consumers


class Channel


CompUnit


class CompUnit


CompUnit::Repository::FileSystem


class CompUnit::Repository::FileSystem


CompUnit::Repository::Installation


class CompUnit::Repository::Installation


Distribution related information


class Distro


Formal grammar made up of named regexes


class Grammar


Iterate over contents of files specified on command line


class IO::ArgFiles


Use multiple IO handles as if they were one


class IO::CatHandle


Opened file or stream


class IO::Handle


Asynchronous notification for file and directory changes





class IO::Notification


Changes in a file, produced by watch-file


class IO::Notification::Change


File or directory path


class IO::Path


IO::Path pre-loaded with IO::Spec::Cygwin


class IO::Path::Cygwin


IO::Path parts encapsulation


class IO::Path::Parts


IO::Path pre-loaded with IO::Spec::QNX


class IO::Path::QNX


IO::Path pre-loaded with IO::Spec::Unix


class IO::Path::Unix


IO::Path pre-loaded with IO::Spec::Win32


class IO::Path::Win32


Buffered inter-process string or binary stream


class IO::Pipe


Asynchronous socket in TCP or UDP


class IO::Socket::Async


A tap for listening TCP sockets


class IO::Socket::Async::ListenSocket


TCP Socket


class IO::Socket::INET


Platform specific operations on file and directory paths


class IO::Spec


Platform specific operations on file and directory paths for Cygwin


class IO::Spec::Cygwin


Platform specific operations on file and directory paths QNX


class IO::Spec::QNX


Platform specific operations on file and directory paths for POSIX


class IO::Spec::Unix


Platform specific operations on file and directory paths for Windows


class IO::Spec::Win32


Path to special I/O device


class IO::Special


Kernel related information


class Kernel


A low-level, re-entrant, mutual exclusion lock


class Lock


Condition variables used in locks


class Lock::ConditionVariable


Result of a successful regex match


class Match


Block in a Pod document


class Pod::Block


Verbatim code block in a Pod document


class Pod::Block::Code


Comment in a Pod document


class Pod::Block::Comment


Declarator block in a Pod document


class Pod::Block::Declarator


Named block in a Pod document


class Pod::Block::Named


Paragraph in a Pod document


class Pod::Block::Para


Table in a Pod document


class Pod::Block::Table


Pod definition list


class Pod::Defn


Pod formatting code


class Pod::FormattingCode


Heading in a Pod document


class Pod::Heading


Item in a Pod enumeration list


class Pod::Item


Running process (filehandle-based interface)


class Proc


Running process (asynchronous interface)


class Proc::Async


Status/result of an asynchronous computation


class Promise


String pattern


class Regex


Control access to shared resources by multiple threads


class Semaphore


Live Supply factory


class Supplier


Cached live Supply factory


class Supplier::Preserving


Asynchronous data stream with multiple subscribers


class Supply


Concurrent execution of code (low-level)


class Thread


Scheduler that distributes work among a pool of threads


class ThreadPoolScheduler


Unicode related information


class Unicode


Raku Virtual Machine related information


class VM


Subscription to a Supply


class Tap


code

A supply is a thread-safe, asynchronous data stream like a
L<C<Channel>|/type/Channel>, but it can have multiple subscribers
(I<taps>) that all get the same values flowing through the supply.


It is a thread-safe implementation of the
L<Observer Pattern|https://en.wikipedia.org/wiki/Observer_pattern>,
and central to supporting reactive programming in Raku.


There are two types of Supplies: C<live> and C<on demand>. When tapping into a
C<live> supply, the tap will only see values that are flowing through the
supply B<after> the tap has been created. Such supplies are normally infinite
in nature, such as mouse movements. Closing such a tap does not stop mouse
events from occurring, it just means that the values will go by unseen. All
tappers see the same flow of values.


A tap on an C<on demand> supply will initiate the production of values, and
tapping the supply again may result in a new set of values. For example,
C<Supply.interval> produces a fresh timer with the appropriate interval each
time it is tapped. If the tap is closed, the timer simply stops emitting values
to that tap.


A C<live> C<Supply> is obtained from the L<C<Supplier>|/type/Supplier>
factory method C<Supply>. New values are emitted by calling C<emit> on
the L<C<Supplier>|/type/Supplier> object.


my $supplier = Supplier.new;
my $supply = $supplier.Supply;
$supply.tap(-> $v { say "$v" });
$supplier.emit(42); # Will cause the tap to output "42"


The L<live method|#method live> returns C<True> on live supplies. Factory
methods such as L<interval|#method interval>, L<from-list|#method from-list>
will return I<on demand> supplies.


A live C<Supply> that keeps values until tapped the first time can be created
with L<C<Supplier::Preserving>|/type/Supplier::Preserving>.


Further examples can be found in the L<concurrency page|/language/concurrency#Supplies>.


Creates a new tap (a kind of subscription if you will), in addition to all
existing taps. The first positional argument is a piece of code that will be
called when a new value becomes available through the C<emit> call.


The C<&done> callback can be called in a number of cases: if a supply block is being tapped, when a C<done> routine is reached;
if a supply block is being tapped, it will be automatically triggered if the supply block reaches the end;
if the C<done> method is called on the parent L<C<Supplier>|/type/Supplier>
(in the case of a supply block, if there are multiple Suppliers referenced by C<whenever>, they must
all have their C<done> method invoked for this to trigger the C<&done> callback of the tap as the
block will then reach its end).


The C<&quit> callback is called if the tap is on a supply block which exits with an error. It is also
called if the C<quit> method is invoked on the parent L<C<Supplier>|/type/Supplier> (in the case of a supply block any
one L<C<Supplier>|/type/Supplier> quitting with an uncaught exception will call the C<&quit> callback as the block will
exit with an error). The error is passed as a parameter to the callback.


The C<&tap> callback is called once the L<C<Tap>|/type/Tap> object is created,
which is passed as a parameter to the callback. The callback is called ahead of
C<emit>/C<done>/C<quit>, providing a reliable way to get the L<C<Tap>|/type/Tap> object. One
case where this is useful is when the C<Supply> begins emitting values
synchronously, since the call to C<.tap> won't return the L<C<Tap>|/type/Tap> object until
it is done emitting, preventing it from being stopped if needed.


Method C<tap> returns an object of type L<C<Tap>|/type/Tap>, on which you can
call the C<close> method to cancel the subscription.


my $s = Supply.from-list(0 .. 5);
my $t = $s.tap(-> $v { say $v }, done => { say "no more ticks" });


Creates a tap on the given supply with the given code.  Differently from
C<tap>, the given code is guaranteed to be executed by only one thread at
a time.


Equivalent to calling L«C<.List.Capture>|/type/List#method_Capture»
on the invocant.


Returns a L<C<Channel>|/type/Channel> object that will receive all future values
from the supply, and will be C<close>d when the Supply is done, and quit (shut
down with error) when the supply is quit.


Returns a L<C<Promise>|/type/Promise> that will be kept when the C<Supply> is
C<done>. If the C<Supply> also emits any values, then the L<C<Promise>|/type/Promise> will be
kept with the final value. Otherwise, it will be kept with L<C<Nil>|/type/Nil>. If the
C<Supply> ends with a C<quit> instead of a C<done>, then the L<C<Promise>|/type/Promise> will
be broken with that exception.


my $supplier = Supplier.new;
my $s = $supplier.Supply;
my $p = $s.Promise;
$p.then(-> $v { say "got $v.result()" });
$supplier.emit('cha');         # not output yet
$supplier.done();              # got cha


The L<C<Promise>|/type/Promise> method is most useful when dealing with supplies that will tend
to produce just one value, when only the final value is of interest, or when
only completion (successful or not) is relevant.


Returns C<True> if the supply is "live", that is, values are emitted to taps
as soon as they arrive. Always returns C<True> in the default C<Supply> (but
for example on the supply returned from C<Supply.from-list> it's C<False>).


say Supplier.new.Supply.live;    # OUTPUT: «True␤»


method schedule-on(Supply:D: Scheduler $scheduler)


Runs the emit, done and quit callbacks on the specified scheduler.


This is useful for GUI toolkits that require certain actions to be run from
the GUI thread.


Methods that wait until the supply is done


Taps the C<Supply> it is called on, and blocks execution until the either the supply
is C<done> (in which case it evaluates to the final value that was emitted on the
C<Supply>, or L<C<Nil>|/type/Nil> if not value was emitted) or C<quit> (in which case it will throw
the exception that was passed to C<quit>).


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


role Systemic

Methods

method auth

method config

method desc

method name

method signature

method version

method gist

method Str

See Also