Documentation for method new

Documentation for method new, assembled from the following types:

class Mu

From Mu

(Mu) 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.

class Backtrace

From Backtrace

(Backtrace) method new

Defined as:

multi method new(--> Backtrace:D)

Creates a new backtrace, using its calling location as the origin of the backtrace.

my $backtrace = Backtrace.new;

role Blob

From Blob

(Blob) method new

Defined as:

method new(*@codes)

Creates a Blob from a list of integers.

my $blob = Blob.new([123]);

class Complex

From Complex

(Complex) method new

Defined as:

multi method new(Real $reReal $im --> Complex:D)

Creates a new Complex object from real and imaginary parts.

my $complex = Complex.new(11);

class ComplexStr

From ComplexStr

(ComplexStr) method new

method new(Complex $iStr $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)"␤» 

class Date

From Date

(Date) method new

Defined as:

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(204211);
$date = Date.new(year => 2042month => 1day => 1);
$date = Date.new("2042-01-01");
$date = Date.new(Instant.from-posix: 1482155532);
$date = Date.new(DateTime.now);

class DateTime

From DateTime

(DateTime) method new

Defined as:

multi method new(Int :$year!Int :$month = 1Int :$day = 1,
                 Int :$hour = 0Int :$minute = 0:$second = 0,
                 Int :$timezone = 0:&formatter)
multi method new(Date :$date!,
                 Int :$hour = 0Int :$minute = 0:$second = 0,
                 Int :$timezone = 0:&formatter)
multi method new(Int() $yearInt() $monthInt() $day,
                 Int() $hourInt $minute$second,
                 Int() :$timezone = 0:&formatter)
multi method new(Instant:D $i,  :$timezone=0:&formatter)
multi method new(Int: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 an Int 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(201511# First January of 2015 
                         111);   # Hour, minute, second with default timezone 
$datetime = DateTime.new(now);                       # Instant. 
# from a Unix timestamp 
say $datetime = DateTime.new(1470853583);            # OUTPUT: «2016-08-10T18:26:23Z␤» 
$datetime = DateTime.new("2015-01-01T03:17:30+0500"# Formatted string 

class Failure

From Failure

(Failure) method new

Defined as:

method new(Failure:D: $payload --> Failure)

Returns a new Failure instance with the given 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‼␤» 

role Rational

From Rational

(Rational) method new

method new(NuT:D: $numeratorDeT:D: $denominator --> Rational:D)

Creates a new rational object from numerator and denominator.

class Map

From Map

(Map) method new

Defined as:

method new(*@args)

Creates a new Map from a list of alternating keys and values, with the same semantics as described for hash assigning in the Hash documentation, except, for literal pair handling. To ensure pairs correctly get passed, add extra parentheses around all the arguments.

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 part of Map's contents 
say Map.new( ('a'1:b(2)) ).keys# OUTPUT: «(a b)␤» 

class IO::CatHandle

From IO::CatHandle

(IO::CatHandle) method new

Defined as:

method new(*@handles:&on-switch:$chomp = True:$nl-in = ["\n""\r\n"], Str :$encodingBool :$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 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 @handles list, processing each argument as follows: the Cool objects will be coerced to IO::Path; 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 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 defined :$encoding and True :$bin is a fatal error resulting in X::IO::BinaryAndEncoding exception thrown. If :$encoding is not set and nor :$bin is not 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.

class IO::Path

From IO::Path

(IO::Path) method new

Defined as:

multi method new(Str:D $pathIO::Spec :$SPEC = $*SPECStr() :$CWD = $*CWD)
multi method new(
    :$basename!:$dirname = '.':$volume = ''
    IO::Spec :$SPEC = $*SPECStr() :$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).

class IO::Path::Cygwin

From IO::Path::Cygwin

(IO::Path::Cygwin) 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.

class IO::Path::QNX

From IO::Path::QNX

(IO::Path::QNX) 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.

class IO::Path::Unix

From IO::Path::Unix

(IO::Path::Unix) 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.

class IO::Path::Win32

From IO::Path::Win32

(IO::Path::Win32) 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.

class IO::Socket::INET

From IO::Socket::INET

(IO::Socket::INET) method new

multi method new(
        :$host,
        :$port,
        :$family = 2,
        :$encoding = 'utf-8',
        :$nl-in = "\r\n",
    --> IO::Socket::INET:D)
multi method new(
        :$localhost,
        :$localport,
        :$family = 2,
        :$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. Otherwise it opens a connection to $host on port $port.

$family defaults to 2 for IPv4, and can be set to 3 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.

class IO::Special

From IO::Special

(IO::Special) 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.

class IntStr

From IntStr

(IntStr) method new

method new(Int $iStr $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"␤» 

class Uni

From Uni

(Uni) method new

method new(*@codes --> Uni:D)

Creates a new Uni instance from the given codepoint numbers.

class Nil

From Nil

(Nil) method new

method new(*@)

Returns Nil

class NumStr

From NumStr

(NumStr) method new

method new(Num $iStr $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"␤» 

class Pair

From Pair

(Pair) method new

Defined as:

multi method new(Pair: Mu  $keyMu  $value)
multi method new(Pair: Mu :$keyMu :$value)

Constructs a new Pair object.

class Proc

From Proc

(Proc) method 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 run(
        *@args ($*@),
        :$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)
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 "-", which means 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, so 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.

$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.

class Proc::Async

From Proc::Async

(Proc::Async) method new

multi method new(*@ ($path*@args), :$w:$enc:$translate-nl --> Proc::Async:D)
multi method new(   :$path:@args,  :$w:$enc:$translate-nl --> 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.

class Proxy

From Proxy

(Proxy) 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.

class RatStr

From RatStr

(RatStr) method new

method new(Rat $iStr $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"␤» 

class Semaphore

From Semaphore

(Semaphore) method new

method newint $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.

class Seq

From Seq

(Seq) method new

method new(Iterator:D $iter --> Seq:D)

Creates a new Seq object from the iterator passed as the single argument.

class Supplier

From Supplier

(Supplier) method new

method new()

The Supplier constructor.

class Thread

From Thread

(Thread) method new

method new(:&code!Bool :$app_lifetime = FalseStr :$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.

class Version

From Version

(Version) 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.