Combined from primary sources listed below.
See primary docmentation in context for method new.
multi method new(Str:D $path, IO::Spec :$SPEC = $*SPEC, Str() :$CWD = $*CWD)
multi method new(
:$basename!, :$dirname = '.', :$volume = ''
IO::Spec :$SPEC = $*SPEC, Str() :$CWD = $*CWD
)
Creates a new IO::Path object from a path string (which is being parsed for volume, directory name and basename), or from volume, directory name and basename passed as named arguments.
The path's operation will be performed using :$SPEC semantics (defaults to current $*SPEC) and will use :$CWD as the directory the path is relative to (defaults to $*CWD).
If $path includes the null byte, it will throw an Exception with a "Cannot use null character (U+0000) as part of the path" message.
See primary docmentation in context for method new.
method new-unit(| --> CompUnit::PrecompilationUnit:D)
{ ... }
Prepare a new implementation specific PrecompilationUnit for storage
See primary docmentation in context for method new.
See primary docmentation in context for method new.
See primary docmentation in context for method new.
method new(Telemetry::Sampler: @instruments --> Telemetry::Sampler:D)
The new method takes a list of instruments. If no instruments are specified, then it will look at the RAKUDO_TELEMETRY_INSTRUMENTS environment variable to find specification of instruments. If that is not available either, then Telemetry::Instrument::Usage and Telemetry::Instrument::ThreadPool will be assumed.
Instruments can be specified by either the type object of the instrument class (e.g. Telemetry::Instrument::Usage) or by a string, in which case it will be automatically prefixed with "Telemetry::Instrument::", so "Usage" would be the same as Telemetry::Instrument::Usage.
See primary docmentation in context for method new.
multi method new(Failure:D:)
multi method new(Failure:U:)
multi method new(Failure:U: Exception:D \exception)
multi method new(Failure:U: $payload)
multi method new(Failure:U: |cap (*@msg))
Returns a new Failure instance with payload given as argument. If called without arguments on a Failure object, it will throw; on a type value, it will create an empty Failure with no payload. The latter can be either an Exception or a payload for an Exception. A typical payload would be a Str with an error message. A list of payloads is also accepted.
my $e = Failure.new(now.DateTime, 'WELP‼');
say $e;
CATCH{ default { say .^name, ': ', .Str } }
# OUTPUT: «X::AdHoc: 2017-09-10T11:56:05.477237ZWELP‼»
See primary docmentation in context for method new.
method new(
Str:D :$type!, # type of block, e.g. "head"
Int:D :$level = 0, # level of block, e.g. 1 for "=head1"
:%config, # any configuration to be applied
Str:D :$margin = "", # left margin (0 or more spaces)
:@paragraphs, # paragraphs of this block
Bool:D :$for, # this is a =for block
Bool:D :$abbreviated, # this is an abbreviated block
Bool:D :$directive # this is a directive (also abbreviated)
)
The new method can be called to create a new RakuAST::Doc::Block object. It only takes named arguments, with the :type argument being mandatory.
=begin foo
bar
=end foo
my $block = RakuAST::Doc::Block.new(
:margin(" "),
:type<foo>,
:paragraphs("bar\n",)
);
Note that the paragraphs should not contain the left margin whitespace.
The type of block: this is a string with the name. Required. Any name is allowed, but the RakuDoc standard assigns semantics to some names. When these are used, it is assumed that the behavior of the block will adhere to the RakuDoc standard semantics.
The level of the block, specified as an integer value, defaults to 0. Some blocks in RakuDoc can have a number associated with the name, such as =item1 and =head2.
Any config to be associated with this block, defaults to none. Specified as an Associative. Note that when specified, the values must be RakuAST:: objects. So something like:
frobnicate => 42
should be specified as:
frobnicate => RakuAST::IntLiteral.new(42)
The left margin to be applied, specifically when deparsing. Should consist of 0 or more spaces. Defaults to the empty string.
The actual content of the block, specified as a Positional. Each element can either be a string, a RakuAST::Doc::Paragraph or another RakuAST::Doc::Block object. In the case of a string, it is assumed that the :margin has already been removed from each line in the string.
Mutually exclusive indication of the format of the block, mostly used in deparsing. If :for is specified, it is assumed to be a =for block. If :abbreviated is specified, then it is assumed to be a =$type block. If :directive is specified, then is assume to be an abbreviated block that can only occur as an abbreviated block and has special RakuDoc semantics (e.g. =row or =column).
If neither of these are specified, then a "delimited block" (one with a =begin and an =end will be assumed.
See primary docmentation in context for method new.
method new($format --> Callable:D)
Returns a cached Callable object from a sprintf compatible format string. Will create a new Callable object if the given format string had not been seen before.
use v6.e.PREVIEW;
my &zero5 = Formatter.new("%05d");
say zero5(42); # OUTPUT: «00042»
See primary docmentation in context for method new.
method new(\volume, \dirname, \basename)
Create a new IO::Path::Parts object with \volume, \dirname and \basename as respectively the volume, directory name and basename parts.
See primary docmentation in context for method new.
method new(*@handles, :&on-switch, :$chomp = True,
:$nl-in = ["\n", "\r\n"], Str :$encoding, Bool :$bin)
Creates a new IO::CatHandle object.
The @handles positional argument indicates a source of handles for the IO::CatHandle to read from and can deal with a mixed collection of Cool, IO::Path, and IO::Handle (including IO::Pipe) objects. As input from IO::CatHandle is processed (so operations won't happen during .new call, but only when @handles' data is needed), it will walk through the @handles list, processing each argument as follows:
IO::Path objects will be opened for reading using the IO::CatHandle's (invocant's) attributes for open calls;
un-opened IO::Handle objects will be opened in the same fashion as IO::Path objects;
and already opened IO::Handle objects will have all of their attributes set to the attributes of the invocant IO::CatHandle.
In short, all the @handles end up as IO::Handle objects opened in the same mode and with the same attributes as the invocant IO::CatHandle.
See .on-switch method for details on the :&on-switch named argument, which by default is not set.
The :$encoding named argument specifies the handle's encoding and accepts the same values as IO::Handle.encoding. Set :$bin named argument to True if you wish the handle to be in binary mode. Attempting to specify both a defined :$encoding and a True :$bin is a fatal error resulting in X::IO::BinaryAndEncoding exception thrown. If neither :$encoding is set nor :$bin set to a true value, the handle will default to utf8 encoding.
The :$chomp and :$nl-in arguments have the same meaning as in IO::Handle and take and default to the same values.
See primary docmentation in context for method new.
method new_type(:$base_type!, :$definite!)
Creates a new definite type given a base type and definiteness. $definite should either be 1 for :D types or 0 for :U types.
See primary docmentation in context for method new.
method new(Num $i, Str $s)
The constructor requires both the Num and the Str value, when constructing one directly the values can be whatever is required:
my $f = NumStr.new(42.1e0, "forty two and a bit");
say +$f; # OUTPUT: «42.1»
say ~$f; # OUTPUT: «"forty two and a bit"»
See primary docmentation in context for method new.
CX::Warn objects are created when a warning is thrown in any block.
See primary docmentation in context for method new.
method new(*@args)
Creates a new Map from a list of alternating keys and values, with the same semantics as described in the Hashes and maps documentation, but also accepts Pairs instead of separate keys and values. Use the grouping operator or quote the key to ensure that a literal pair is not interpreted as a named argument.
my %h = Map.new('a', 1, 'b', 2);
# WRONG: :b(2) interpreted as named argument
say Map.new('a', 1, :b(2)).keys; # OUTPUT: «(a)»
# RIGHT: :b(2) interpreted as Pair because of extra parentheses
say Map.new( ('a', 1, :b(2)) ).keys.sort; # OUTPUT: «(a b)»
# RIGHT: 'b' => 2 always creates a Pair
say Map.new('a', 1, 'b' => 2).keys.sort; # OUTPUT: «(a b)»
A shorthand syntax for creating Maps is provided:
my %h is Map = 'a', 1, 'b', 2;
See primary docmentation in context for method new.
method new(NuT:D $numerator, DeT:D $denominator --> Rational:D)
Creates a new rational object from numerator and denominator, which it normalizes to the lowest terms. The $denominator can be zero, in which case the numerator is normalized to -1, 0, or 1 depending on whether the original is negative, zero, or positive, respectively.
See primary docmentation in context for method new.
method new(
Str:D :$letter!, # markup identifier, e.g. "B"
Str:D :$opener = "<", # opener marker
Str:D :$closer = ">", # closer marker
:@atoms, # any atoms of this markup
:@meta, # any meta of this markup
)
The new method can be called to create a new RakuAST::Doc::Markup object. It only takes named arguments, with the :letter argument being mandatory.
B<and>
my $markup = RakuAST::Doc::Markup.new(
:letter<B>,
:atoms("and")
);
Note that all arguments except :letter are optional. So it is possible to create "empty" markup as well.
The "type" of markup object. Generally expected to be an uppercase letter, but this is not enforced. The RakuDoc standard assigns meaning to most ASCII uppercase letters, so one would probably do well adhering to this standard when using ASCII uppercase letters.
The markup opening sequence marker. Defaults to "<". Mostly used for stringification.
The markup closing sequence marker. Defaults to ">". Mostly used for stringification.
The actual content of the markup, specified as a Positional. Each element can either be a string or another RakuAST::Doc::Markup object.
The meta-information of the markup, specified as a Positional. Each element can either be a string or another RakuAST::Doc::Markup object. Note that the RakuDoc standard associates certain meaning to the meta-information for certain letters, such as the meta-information being a URL in the case of L being the letter.
See primary docmentation in context for method new.
Same as IO::Path.new, except :$SPEC cannot be set and defaults to IO::Spec::Win32, regardless of the operating system the code is being run on.
See primary docmentation in context for method new.
See primary docmentation in context for method new.
method new(Complex $i, Str $s)
The constructor requires both the Complex and the Str value, when constructing one directly the values can be whatever is required:
my $f = ComplexStr.new(42+0i, "forty two (but complicated)");
say +$f; # OUTPUT: «42+0i»
say ~$f; # OUTPUT: «"forty two (but complicated)"»
See primary docmentation in context for method new.
Same as IO::Path.new, except :$SPEC cannot be set and defaults to IO::Spec::Cygwin, regardless of the operating system the code is being run on.
See primary docmentation in context for method new.
method new(
Str:D :$WHEREFORE, # the associated RakuAST object
:@leading, # leading lines of documentation
:@trailing # trailing lines of documentation
)
The new method can be called to create a new RakuAST::Doc::Declarator object. It only takes named arguments.
# there is no syntax for creating just a ::Declarator object
my $declarator = RakuAST::Doc::Declarator.new(
:WHEREFORE(RakuAST::VarDeclaration::Simple.new(...)),
:leading("line 1 leading","line 2 leading"),
:trailing("line 1 trailing","line 2 trailing")
);
Note that the leading and trailing documentation may contain any left margin whitespace.
The RakuAST object for which this declarator contains the documentation.
A Positional with the lines of leading documentation strings.
A Positional with the lines of trailing documentation strings.
See primary docmentation in context for method new.
method (:$name, :$repr = 'P6opaque', :$ver, :$auth)
Creates a new type from the metamodel, which we can proceed to build
my $type = Metamodel::ClassHOW.new_type(name => "NewType",
ver => v0.0.1,
auth => 'github:raku' );
$type.HOW.add_method($type,"hey", method { say "Hey" });
$type.hey; # OUTPUT: «Hey»
$type.HOW.compose($type);
my $instance = $type.new;
$instance.hey; # OUTPUT: «Hey»
We add a single method by using Higher Order Workings methods, and then we can use that method directly as class method; we can then compose the type, following which we can create already an instance, which will behave in the exact same way.
See primary docmentation in context for method new.
multi method new(*@ ($path, *@args), :$w, :$enc, :$translate-nl, :$arg0,
:$win-verbatim-args = False,
:$started = False --> Proc::Async:D)
multi method new( :$path, :@args, :$w, :$enc, :$translate-nl, :$arg0,
:$win-verbatim-args = False,
:$started = False --> Proc::Async:D)
Creates a new Proc::Async object with external program name or path $path and the command line arguments @args.
If :w is passed to new, then a pipe to the external program's standard input stream (stdin) is opened, to which you can write with write and say.
The :enc specifies the encoding for streams (can still be overridden in individual methods) and defaults to utf8.
If :translate-nl is set to True (default value), OS-specific newline terminators (e.g. \r\n on Windows) will be automatically translated to \n.
If :arg0 is set to a value, that value is passed as arg0 to the process instead of the program name.
The :started attribute is set by default to False, so that you need to start the command afterwards using .start. You probably don't want to do this if you want to bind any of the handlers, but it's OK if you just need to start an external program immediately.
On Windows the flag $win-verbatim-args disables all automatic quoting of process arguments. See this blog for more information on windows command quoting. The flag is ignored on all other platforms. The flag was introduced in Rakudo version 2020.06 and is not present in older releases. By default, it's set to False, in which case arguments will be quoted according to Microsoft convention.
See primary docmentation in context for method new.
multi method new(
:$host,
:$port,
:$family = PF_INET,
:$encoding = 'utf-8',
:$nl-in = "\r\n",
--> IO::Socket::INET:D)
multi method new(
:$localhost,
:$localport,
:$family = PF_INET,
:$listen,
:$encoding = 'utf-8',
:$nl-in = "\r\n",
--> IO::Socket::INET:D)
Creates a new socket.
If :$listen is True, creates a new socket that listen on :$localhost (which can be an IP address or a domain name) on port :$localport; in other words the :$listen flag determines the server mode of the socket. Otherwise (i.e., :$listen is False), the new socket opens immediately a connection to :$host on port :$port.
:$family defaults to PF_INET constant for IPv4, and can be set to PF_INET6 constant for IPv6.
For text operations (such as method lines and method get), :$encoding specifies the encoding, and :$nl-in determines the character(s) that separate lines.
See primary docmentation in context for method new.
Same as IO::Path.new, except :$SPEC cannot be set and defaults to IO::Spec::QNX, regardless of the operating system the code is being run on.
See primary docmentation in context for method new.
multi method new()
multi method new($n)
Num.new without argument will create a Num with the value 0e0. With an argument, it will be coerced to Num and then returned.
say Num.new(⅓); # OUTPUT: «0.3333333333333333»
See primary docmentation in context for method new.
method new-from-pairs(*@pairs --> Setty:D)
Constructs a Setty object from a list of Pair objects given as positional arguments:
say Set.new-from-pairs: 'butter' => 0.22, 'salt' => 0, 'sugar' => 0.02;
# OUTPUT: «Set(butter sugar)»
Note: be sure you aren't accidentally passing the Pairs as positional arguments; the quotes around the keys in the above example are significant.
See primary docmentation in context for method new.
method new( int $permits )
Initialize the semaphore with the number of permitted accesses. E.g. when set to 2, program threads can pass the acquire method twice until it blocks on the third time acquire is called.
See primary docmentation in context for method new.
method new_type(:$name!, :$base_type?, :$repr = 'P6opaque', :$is_mixin)
Creates a new type object for an enum. $name is the enum name, $base_type is the type given when the enum is declared using a scoped declaration (if any), and $repr is the type representation passed to the enum using the repr trait. $is_mixin is unused.
See primary docmentation in context for method new.
method new-from-daycount($daycount,:&formatter --> Date:D)
Creates a new Date object given $daycount which is the number of days from epoch Nov. 17, 1858, i.e. the Modified Julian Day. Optionally accepts a formatter as a named parameter.
say Date.new-from-daycount(49987); # OUTPUT: «1995-09-27»
See primary docmentation in context for method new.
multi method new($year, $month, $day, :&formatter --> Date:D)
multi method new(:$year!, :$month = 1, :$day = 1 --> Date:D)
multi method new(Str $date --> Date:D)
multi method new(Instant:D $dt --> Date:D)
multi method new(DateTime:D $dt --> Date:D)
Creates a new Date object, either from a triple of (year, month, day) that can be coerced to integers, or from a string of the form YYYY-MM-DD (ISO 8601), or from an Instant or DateTime object. Optionally accepts a formatter as a named parameter.
my $date = Date.new(2042, 1, 1);
$date = Date.new(year => 2042, month => 1, day => 1);
$date = Date.new("2042-01-01");
$date = Date.new(Instant.from-posix: 1482155532);
$date = Date.new(DateTime.now);
Since Rakudo 2022.03, the "day" argument can also be a callable, with * representing the last day in a month, and the possibility of getting to the day counting from the last one:
say Date.new(2042, 2, *); # OUTPUT: «2042-02-28»
say Date.new(2044, 2, *); # OUTPUT: «2044-02-29»
See primary docmentation in context for method new.
method new($format --> Format:D)
Creates a new Format object from a sprintf compatible format string.
use v6.e.PREVIEW;
my $d = Format.new("%05d");
say $d; # OUTPUT: «%05d»
say $d(42); # OUTPUT: «00042»
See primary docmentation in context for method new.
multi method new(*%attrinit)
Default method for constructing (create + initialize) new objects of a class. This method expects only named arguments which are then used to initialize attributes with accessors of the same name.
Classes may provide their own new method to override this default.
new triggers an object construction mechanism that calls submethods named BUILD in each class of an inheritance hierarchy, if they exist. See the documentation on object construction for more information.
See primary docmentation in context for method new.
method new(Rat $i, Str $s)
The constructor requires both the Rat and the Str value, when constructing one directly the values can be whatever is required:
my $f = RatStr.new(42.1, "forty two and a bit");
say +$f; # OUTPUT: «42.1»
say ~$f; # OUTPUT: «"forty two and a bit"»
See primary docmentation in context for method new.
method new(:&FETCH!, :&STORE! --> Proxy:D)
Creates a new Proxy object. &FETCH is called with one argument (the proxy object) when the value is accessed, and must return the value that the fetch produces. &STORE is called with two arguments (the proxy object, and the new value) when a new value is stored in the container.
See primary docmentation in context for method new.
method new(IO::Path $prefix, IO::Path :$meta-file = IO::Path)
Creates a new Distribution::Path instance from the META6.json file found at the given $prefix, and from which all paths in the metadata will be prefixed with. :$meta-file may optionally be passed if a filename other than META6.json needs to be used.
See primary docmentation in context for method new.
proto method new(Seq: |) {*}
multi method new(Seq: Iterator:D $iter)
multi method new(Seq:)
Creates a new Seq object from the supplied iterator passed as the single argument. Creates an empty Seq if called with no argument.
See primary docmentation in context for method new.
method new(:$!what!)
Takes a single required attribute what. It is unlikely that you will ever need to construct one of these objects yourself.
See primary docmentation in context for method new.
method new(*@atoms)
The new method must be called to create a new RakuAST::Doc::Paragraph object. It takes any number of positional arguments as the atoms of the logical paragraph, where an atom is either a string or a RakuAST::Doc::Markup object.
Typically a RakuAST::Doc::Paragraph object is only created if a logical paragraph has at least one markup object.
my $paragraph = RakuAST::Doc::Paragraph.new(
"Text before ",
RakuAST::Doc::Markup.new(:letter<B>, :atoms("and")),
" after markup\n"
);
See primary docmentation in context for method new.
multi method new(Pair: Mu $key, Mu $value)
multi method new(Pair: Mu :$key, Mu :$value)
Constructs a new Pair object.
See primary docmentation in context for method new.
method new-from-pairs(Baggy: *@pairs --> Baggy:D)
Constructs a Baggy objects from a list of Pair objects given as positional arguments:
say Mix.new-from-pairs: 'butter' => 0.22, 'sugar' => 0.1, 'sugar' => 0.02;
# OUTPUT: «Mix(butter(0.22) sugar(0.12))»
Note: be sure you aren't accidentally passing the Pairs as positional arguments; the quotes around the keys in the above example are significant.
See primary docmentation in context for method new.
Same as IO::Path.new, except :$SPEC cannot be set and defaults to IO::Spec::Unix, regardless of the operating system the code is being run on.
See primary docmentation in context for method new.
multi method new(Any:U $type)
multi method new(Any:D \value --> Int:D)
multi method new(int \value --> Int:D)
The first form will throw an exception; the second and third form will create a new Int from the actual integer value contained in the variable.
See primary docmentation in context for method new.
method new( :$feature, :$did-you-mean, :$workaround)
This is the default constructor for X:NYI which can take three parameters with obvious meanings.
class Nothing {
method ventured( $sub, **@args) {
X::NYI.new( feature => &?ROUTINE.name,
did-you-mean => "gained",
workaround => "Implement it yourself" ).throw;
}
}
my $nothing = Nothing.new;
$nothing.ventured("Nothing", "Gained");
In this case, we are throwing an exception that indicates that the ventured routine has not been implemented; we use the generic &?ROUTINE.name to not tie the exception to the method name in case it is changed later on. This code effectively throws this exception
# OUTPUT:
# ventured not yet implemented. Sorry.
# Did you mean: gained?
# Workaround: Implement it yourself
# in method ventured at NYI.raku line 6
# in block <unit> at NYI.raku line 14
Using the exception properties, it composes the message that we see there.
See primary docmentation in context for method new.
method new(Str:D $s)
Creates a Version from a string $s. The string is combed for the numeric, alphabetic, and wildcard components of the version object. Any characters other than alphanumerics and asterisks are assumed to be equivalent to a dot. A dot is also assumed between any adjacent numeric and alphabetic characters.
See primary docmentation in context for method new.
multi method new(Real $re, Real $im --> Complex:D)
Creates a new Complex object from real and imaginary parts.
my $complex = Complex.new(1, 1);
say $complex; # OUTPUT: «1+1i»
When created without arguments, both parts are considered to be zero.
say Complex.new; # OUTPUT: «0+0i»
See primary docmentation in context for method new.
multi method new()
multi method new(Int:D $offset)
multi method new(Mu \ex)
multi method new(Mu \ex, Int:D $offset)
multi method new(List:D $bt)
multi method new(List:D $bt, Int:D $offset)
Creates a new backtrace, using its calling location as the origin of the backtrace or the $offset that is passed as a parameter. If an object or a list (that will already contain a backtrace in list form) is passed, they will be used instead of the current code.
my $backtrace = Backtrace.new;
See primary docmentation in context for method new.
multi method new(Junction: \values, Str :$type!)
multi method new(Junction: Str:D \type, \values)
These constructors build a new junction from the type that defines it and a set of values.
my $j = Junction.new(<Þor Oðinn Loki>, type => "all");
my $n = Junction.new( "one", 1..6 )
The main difference between the two multis is how the type of the Junction is passed as an argument; either positionally as the first argument, or as a named argument using type.
See primary docmentation in context for method new.
multi method new(Blob:)
multi method new(Blob: Blob:D $blob)
multi method new(Blob: int @values)
multi method new(Blob: @values)
multi method new(Blob: *@values)
Creates an empty Blob, or a new Blob from another Blob, or from a list of integers or values (which will have to be coerced into integers):
my $blob = Blob.new([1, 2, 3]);
say Blob.new(<1 2 3>); # OUTPUT: «Blob:0x<01 02 03>»
See primary docmentation in context for method new.
See primary docmentation in context for method new.
method new_type(:$name = '<anon>', :$repr, :$ver, :$auth)
Creates a new package, with optional representation, version and auth field.
See primary docmentation in context for method new.
method new($hash, :$prefix)
Creates a new Distribution::Hash instance from the metadata contained in $hash. All paths in the metadata will be prefixed with :$prefix.
See primary docmentation in context for method new.
method new(*@codes --> Uni:D)
Creates a new Uni instance from the given codepoint numbers.
See primary docmentation in context for method new.
multi method new(Int :$year!, Int :$month = 1, Int :$day = 1,
Int :$hour = 0, Int :$minute = 0, :$second = 0,
Int :$timezone = 0, :&formatter)
multi method new(Date :$date!,
Int :$hour = 0, Int :$minute = 0, :$second = 0,
Int :$timezone = 0, :&formatter)
multi method new(Int() $year, Int() $month, Int() $day,
Int() $hour, Int $minute, $second,
Int() :$timezone = 0, :&formatter)
multi method new(Instant:D $i, :$timezone=0, :&formatter)
multi method new(Numeric:D $posix, :$timezone=0, :&formatter)
multi method new(Str:D $format, :$timezone=0, :&formatter)
Creates a new DateTime object. One option for creating a new DateTime object is from the components (year, month, day, hour, ...) separately. Another is to pass a Date object for the date component, and specify the time component-wise. Yet another is to obtain the time from an Instant, and only supply the time zone and formatter. Or instead of an Instant you can supply a Numeric as a UNIX timestamp.
You can also supply a Str formatted in ISO 8601 timestamp notation or as a full RFC 3339 date and time. Strings should be formatted as yyyy-mm-ddThh:mm:ssZ or 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 X::Temporal::InvalidFormat. If you supply a string that includes a time zone and supply the timezone named argument, an exception of 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 day parameter can be a Callable, with * returning the last day in the month, and *-n returning the last but 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»
See primary docmentation in context for method new.
method new(:&code!, Bool :$app_lifetime = False, Str :$name = '<anon>' --> Thread:D)
Creates and returns a new Thread, without starting it yet. &code is the code that will be run in a separate thread.
$name is a user-specified string that identifies the thread.
If $app_lifetime is set to True, then the thread is killed when the main thread of the process terminates. If set to False, the process will only terminate when the thread has finished.
See primary docmentation in context for method new.
method new(Int $i, Str $s)
The constructor requires both the Int and the 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"»
See primary docmentation in context for routine new.
method new(Proc:U:
:$in = '-',
:$out = '-',
:$err = '-',
Bool :$bin = False,
Bool :$chomp = True,
Bool :$merge = False,
Str:D :$enc = 'UTF-8',
Str:D :$nl = "\n",
--> Proc:D)
sub shell(
$cmd,
:$in = '-',
:$out = '-',
:$err = '-',
Bool :$bin = False,
Bool :$chomp = True,
Bool :$merge = False,
Str:D :$enc = 'UTF-8',
Str:D :$nl = "\n",
:$cwd = $*CWD,
Hash() :$env = %*ENV
--> Proc:D)
new creates a new Proc object, whereas run or shell create one and spawn it with the command and arguments provided in @args or $cmd, respectively.
$in, $out and $err are the three standard streams of the to-be-launched program, and default to "-" meaning they inherit the stream from the parent process. Setting one (or more) of them to True makes the stream available as an IO::Pipe object of the same name, like for example $proc.out. You can set them to False to discard them. Or you can pass an existing IO::Handle object (for example IO::Pipe) in, in which case this handle is used for the stream.
Please bear in mind that the process streams reside in process variables, not in the dynamic variables that make them available to our programs. Thus, modifying the dynamic filehandle variables (such as $*OUT) inside the host process will have no effect in the spawned process, unlike $*CWD and $*ENV, whose changes will be actually reflected in it.
my $p-name = "/tmp/program.raku";
my $program = Q:to/END/;
#!/usr/bin/env raku
$*OUT.say( qq/\t$*PROGRAM: This goes to standard output/ );
END
spurt $p-name, $program;
$*OUT.put: "1. standard output before doing anything weird";
{
temp $*OUT = open '/tmp/out.txt', :w;
$*OUT.put: "2. temp redefine standard output before this message";
shell( "raku $p-name" ).so;
}
$*OUT.put: "3. everything should be back to normal";
# OUTPUT
# 1. standard output before doing anything weird
# /tmp/program.raku: This goes to standard output
# 3. everything should be back to normal
# /tmp/out.txt will contain:
# 2. temp redefine standard output before this message
This program shows that the program spawned with shell is not using the temporary $*OUT value defined in the host process (redirected to /tmp/out.txt), but the initial STDOUT defined in the process.
$bin controls whether the streams are handled as binary (i.e. Blob object) or text (i.e. Str objects). If $bin is False, $enc holds the character encoding to encode strings sent to the input stream and decode binary data from the output and error streams.
With $chomp set to True, newlines are stripped from the output and err streams when reading with lines or get. $nl controls what your idea of a newline is.
If $merge is set to True, the standard output and error stream end up merged in $proc.out.