TITLE

SUBTITLE

This role is an interface for objects that provide API access mapping META6 data
to the files it represents. Objects that fulfill the C<Distribution> role can be
read by e.g.
L<C<CompUnit::Repository::Installation>|/type/CompUnit::Repository::Installation>.
Generally a C<Distribution> provides read access to a set of modules and
metadata. These may be backed by the filesystem
(L<C<Distribution::Path>|/type/Distribution::Path>,
L<C<Distribution::Hash>|/type/Distribution::Hash>) but could also read from an e.g.
tar file or socket.


head

Returns a Hash with the representation of the metadata. Please note that an
actual C<META6.json> file does not need to exist, just a representation in that
format.


method content($name-path --> IO::Handle:D) { ... }


Returns an L<C<IO::Handle>|/type/IO::Handle> to the file represented by C<$name-path>. C<$name-path>
is a relative path as it would be found in the metadata such as C<lib/Foo.rakumod>
or C<resources/foo.txt>.


root

Invocable code object


role Callable


Object that can be treated as a date


role Dateish


Support for character encodings.


role Encoding


Iterators that can predict number of values


role PredictiveIterator


Provide leading/trailing doc functionality


class RakuAST::Doc::DeclaratorTarget


Number stored as numerator and denominator


role Rational


Non-complex number


role Real


String or object that can act as a string


role Stringy


Distribution


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 Distribution


code

A L<C<Distribution>|/type/Distribution> implementation backed by the filesystem. It
does not require a C<META6.json> file, essentially providing a lower level
L<C<Distribution::Path>|/type/Distribution::Path>.


Creates a new C<Distribution::Hash> instance from the metadata contained in
C<$hash>. All paths in the metadata will be prefixed with C<:$prefix>.


Returns a Hash with the representation of the metadata.


Please check
L<the C<content> method in Distribution::Locally|/type/Distribution::Locally#method_content>.


Native integer


class int


Dual value number and string


class Allomorph


Thing/object


class Any


Abstract representation of a piece of source code


class AST


Integer (native storage at the platform's atomic operation size)


class atomicint


Code object with its own lexical scope


class Block


Captures the current frame state


class CallFrame


Code object


class Code


Encapsulates instructions about how strings should be sorted


class Collation


Information related to the compiler that is being used


class Compiler


Complex number


class Complex


Dual value complex number and string


class ComplexStr


Object that can be treated as both a string and number


class Cool


Scheduler that synchronously executes code on the current thread


class CurrentThreadScheduler


Calendar date


class Date


Calendar date with time


class DateTime


Distribution::Locally


class Distribution::Locally


Distribution::Path


class Distribution::Path


Every one of the resources installed with a distribution


class Distribution::Resource


Length of time


class Duration


Management of available encodings


class Encoding::Registry


Rational number (arbitrary-precision)


class FatRat


Rakudo-specific class that wraps around code in other languages (generally NQP)


class ForeignCode


Convert values to a string given a format specification


class Format


Produce Callable for given format specification


class Formatter


An object for performing batches of work in parallel with ordered
output


class HyperSeq


Placeholder for multiple unspecified values/arguments


class HyperWhatever


Specific moment in time


class Instant


Integer (arbitrary-precision)


class Int


Dual value integer and string


class IntStr


Logical superposition of values


class Junction


Tagged location in the source code


class Label


A non-blocking, non-re-entrant, mutual exclusion lock


class Lock::Async


Compile-time routine


class Macro


Member function


class Method


The root of the Raku type hierarchy.


class Mu


Absence of a value or a benign failure


class Nil


Floating-point number


class Num


Number or object that can act as a number


role Numeric


Dual value floating-point number and string


class NumStr


Unique identification for an object


class ObjAt


Element of a Signature


class Parameter


Perl related information


class Perl


Item container with custom storage and retrieval


class Proxy


Performs batches of work in parallel without respecting original
order.


class RaceSeq


Raku related information


class Raku


Namespace for holding RakuAST related classes


package RakuAST


Contains the information of a RakuDoc block


class RakuAST::Doc::Block


Contains the declarator docs of a RakuAST object


class RakuAST::Doc::Declarator


Contains the information about RakuDoc markup


class RakuAST::Doc::Markup


Contains the information about a RakuDoc paragraph


class RakuAST::Doc::Paragraph


Rational number (limited-precision)


class Rat


Dual value rational number and string


class RatStr


Code object with its own lexical scope and return handling


class Routine


Holds all information needed to unwrap a wrapped routine.


class Routine::WrapHandle


A mostly transparent container used for indirections


class Scalar


Parameter list pattern


class Signature


String of characters


class Str


Contains the result of a string transformation.


class StrDistance


Subroutine


class Sub


Member function that is not inherited by subclasses


class Submethod


Collect performance state for analysis


class Telemetry


Instrument for collecting Thread data


class Telemetry::Instrument::Thread


Instrument for collecting ThreadPoolScheduler data


class Telemetry::Instrument::ThreadPool


Instrument for collecting getrusage data


class Telemetry::Instrument::Usage


Performance data over a period


class Telemetry::Period


Telemetry instrument pod


class Telemetry::Sampler


Unsigned integer (arbitrary-precision)


Subset UInt


Unique identification for value types


class ValueObjAt


Object representation of a variable for use in traits


class Variable


Module version descriptor


class Version


Placeholder for the value of an unspecified argument


class Whatever


Code object constructed by Whatever-priming


class WhateverCode


Distribution::Hash


class Distribution::Hash


For handling points in civil time, a C<DateTime> object stores year, month,
day, hour, minute (all L<C<Int>|/type/Int>), second (potentially fractional) and
a time zone.


It provides methods for calculating with date (for the Gregorian calendar) and time.


C<DateTime> methods are immutable; if you are tempted to modify one, create a
modified copy instead.


Time zones are handled as L<C<Int>|/type/Int>s in B<seconds> offset from UTC,
not by time zone name.


=begin code
my $dt = DateTime.new(
    year    => 2015,
    month   => 11,
    day     => 21,
    hour    => 16,
    minute  => 1,
);

say $dt;                            # OUTPUT: «2015-11-21T16:01:00Z␤»
say $dt.later(days => 20);          # OUTPUT: «2015-12-11T16:01:00Z␤»
say $dt.truncated-to('hour');       # OUTPUT: «2015-11-21T16:00:00Z␤»
say $dt.in-timezone(-8 * 3600);     # OUTPUT: «2015-11-21T08:01:00-0800␤»

my $now = DateTime.now(formatter => { sprintf "%02d:%02d", .hour, .minute });
say $now;                           # 12:45 (or something like that)
=end code


Since version 6.d, using synthetic codepoints such as 7̈ will result in an
error.


Creates a new C<DateTime> object. One option for creating a new DateTime object
is from the components (year, month, day, hour, ...) separately. Another is to
pass a L<C<Date>|/type/Date> object for the date component, and specify the time
component-wise. Yet another is to obtain the time from an
L<C<Instant>|/type/Instant>, and only supply the time zone and formatter. Or
instead of an Instant you can supply a L<C<Numeric>|/type/Numeric> as a UNIX timestamp.


You can also supply a L<C<Str>|/type/Str> formatted in ISO 8601 timestamp
notation or as a full L<RFC 3339|https://tools.ietf.org/html/rfc3339>
date and time.  Strings should be formatted as C<yyyy-mm-ddThh:mm:ssZ>
or C<yyyy-mm-ddThh:mm:ss+0100>.  We are somewhat less restrictive than the
ISO 8601 standard, as we allow Unicode digits and mixing of condensed
and extended time formats.


An invalid input string throws an exception of type
L<C<X::Temporal::InvalidFormat>|/type/X::Temporal::InvalidFormat>. If you supply a string that includes a time
zone and supply the C<timezone> named argument, an exception of type
L<C<X::DateTime::TimezoneClash>|/type/X::DateTime::TimezoneClash> is thrown.


my $datetime = DateTime.new(year => 2015,
                            month => 1,
                            day => 1,
                            hour => 1,
                            minute => 1,
                            second => 1,
                            timezone => 1);
$datetime = DateTime.new(date => Date.new('2015-12-24'),
                         hour => 1,
                         minute => 1,
                         second => 1,
                         timezone => 1);
$datetime = DateTime.new(2015, 1, 1, # First January of 2015
                         1, 1, 1);   # Hour, minute, second with default time zone
$datetime = DateTime.new(now);                       # Instant.
# from a Unix timestamp
say $datetime = DateTime.new(1470853583.3);          # OUTPUT: «2016-08-10T18:26:23.300000Z␤»
$datetime = DateTime.new("2015-01-01T03:17:30+0500") # Formatted string


Since Rakudo release 2022.03, the C<day> parameter can be a L<C<Callable>|/type/Callable>, with
C<*> returning the last day in the month, and C<*-n> returning the last but
C<n>.


Since Rakudo release 2022.07, it is also possible to just specify a
"YYYY-MM-DD" string to indicate midnight on the given date.


say DateTime.new("2023-03-04");  # OUTPUT: «2023-03-04T00:00:00Z␤»


method now(:$timezone = $*TZ, :&formatter --> DateTime:D)


Creates a new C<DateTime> object from the current system time. A custom
L<formatter|/routine/formatter> and L<timezone|/routine/timezone> can be provided. The C<:$timezone> is
the offset B<in seconds> from L<GMT|https://en.wikipedia.org/wiki/Greenwich_Mean_Time>
and defaults to the value of L«C<$*TZ> variable|/language/variables#index-entry-%24*TZ».


The Raku Knowledge Base


role Distribution

Required Methods

method meta

method content

See Also