TITLE

SUBTITLE

The role provides no methods, but exists so that C<IO()> coercers, which
coerce to L<C<IO::Path>|/type/IO::Path>, correctly type-check the resultant value. The
role is implemented by L<C<IO::Path>|/type/IO::Path> and
L<C<IO::Special>|/type/IO::Special>.


See also the related classes L<C<IO::Handle>|/type/IO::Handle> and
L<C<IO::Path>|/type/IO::Path>.


root

CompUnit::PrecompilationRepository


role CompUnit::PrecompilationRepository


CompUnit::Repository


role CompUnit::Repository


Network socket


role IO::Socket


Scheme for automatically assigning tasks to threads


role Scheduler


Information related to the build system


role Systemic


Input/output related routines


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 IO


Iterate over contents of files specified on command line


This class exists for backwards compatibility reasons and provides no additional
methods to L«C<IO::CatHandle>|/type/IO::CatHandle», so it can be used in the same way as it, for
instance, in this way:


code

If invoked with C<raku io-argfiles.raku *.raku> it will print the contents of all
the files with that extension in the directory. However, that is totally
equivalent to:


head

This class is the magic behind the C<$*ARGFILES> variable, which provides a way
to iterate over files passed in to the program on the command line (i.e.
elements of L<C«@*ARGS»|/language/variables#index-entry-%40%2AARGS>). Thus the
examples above can be simplified like so:


# or
while ! $*ARGFILES.eof {
    say $*ARGFILES.get;
}


Save one of the variations above in a file, say C<argfiles.raku>.  Then create
another file (named, say C<sonnet18.txt> with the contents:


As of 6.d language, C<$*ARGFILES> I<inside>
L<C«sub MAIN»|/language/functions#sub_MAIN> is always set to C<$*IN>, even
when C<@*ARGS> is not empty. That means that


which can be used as C<cat *.raku | raku argfiles-main.raku>, for instance, is
totally equivalent to:


and, in fact, can't be used to process the arguments in the command line, since,
in this case, it would result in a usage error.


Bear in mind that the object C<$*ARGFILES> is going to contain a handle for
every argument in a command line, even if that argument is not a valid file. You
can retrieve them via the C<.handles> method.


That code will fail if any of the arguments is not the valid name of a file. You
will have to deal with that case at another level, checking that
L<C<@*ARGS>|/language/variables#index-entry-%40*ARGS> contains valid file names,
for instance.


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


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


Subscription to a Supply


class Tap


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


class IO::ArgFiles


C<IntStr> is a dual value type, a subclass of both
L«C<Allomorph>|/type/Allomorph», hence L«C<Str>|/type/Str», and
L«C<Int>|/type/Int».


See L«C<Allomorph>|/type/Allomorph» for further details.


=begin code
my $int-str = <42>;
say $int-str.^name;     # OUTPUT: «IntStr␤»

my Int $int = $int-str; # OK!
my Str $str = $int-str; # OK!

# ∈ operator cares about object identity
say 42 ∈ <42  55  1>;   # OUTPUT: «False␤»
=end code


The constructor requires both the L<C<Int>|/type/Int> and the L<C<Str>|/type/Str> value, when constructing one
directly the values can be whatever is required:


my $f = IntStr.new(42, "forty two");
say +$f; # OUTPUT: «42␤»
say ~$f; # OUTPUT: «"forty two"␤»


Returns the integer value of the C<IntStr>.


multi method Numeric(IntStr:D: --> Int:D)
multi method Numeric(IntStr:U: --> Int:D)


The C<:D> variant returns the numeric portion of the invocant. The C<:U> variant issues
a warning about using an uninitialized value in numeric context and then returns value C<0>.


multi method Real(IntStr:D: --> Int:D)
multi method Real(IntStr:U: --> Int:D)


multi infix:<===>(IntStr:D $a, IntStr:D $b)


C<IntStr> Value identity operator. Returns C<True> if the L<C<Int>|/type/Int>
values of C<$a> and C<$b> are L<identical|/routine/===> and their L<C<Str>|/type/Str>
values are also L<identical|/routine/===>. Returns C<False> otherwise.


See Also