Documentation for method Str assembled from the following pages:

Class: Date §

From Date

(Date) method Str §

Defined as:

multi method Str(Date:D: --> Str:D)

Returns a string representation of the invocant, as specified by the formatter. If no formatter was specified, an (ISO 8601) date will be returned.

say Date.new('2015-12-24').Str;                     # OUTPUT: «2015-12-24␤» 
 
my $fmt = { sprintf "%02d/%02d/%04d".month.day.year };
say Date.new('2015-12-24'formatter => $fmt).Str;  # OUTPUT: «12/24/2015␤»

Role: Blob §

From Blob

(Blob) method Str §

Defined as:

multi method Str(Blob:D:)

Throws X::Buf::AsStr with Str as payload. In order to convert to a Str you need to use .decode.

Class: Thread §

From Thread

(Thread) method Str §

method Str(Thread:D: --> Str:D)

Returns a string which contains the invocants thread id and name.

my $t = Thread.new(code => { for 1..5 -> $v { say $v }}name => 'calc thread');
say $t.Str;                           # OUTPUT: «Thread<3>(calc thread)␤»

Role: Sequence §

From Sequence

(Sequence) method Str §

multi method Str(::?CLASS:D:)

Stringifies the cached sequence.

Class: List §

From List

(List) method Str §

Defined as:

method Str(List:D: --> Str:D)

Stringifies the elements of the list and joins them with spaces (same as .join(' ')).

say (1,2,3,4,5).Str# OUTPUT: «1 2 3 4 5␤»

Class: Nil §

From Nil

(Nil) method Str §

method Str()

Warns the user that they tried to stringify a Nil.

Class: Mu §

From Mu

(Mu) method Str §

multi method Str(--> Str)

Returns a string representation of the invocant, intended to be machine readable. Method Str warns on type objects, and produces the empty string.

say Mu.Str;   # Use of uninitialized value of type Mu in string context. 
my @foo = [2,3,1];
say @foo.Str  # OUTPUT: «2 3 1␤»

Class: Backtrace §

From Backtrace

(Backtrace) method Str §

Defined as:

multi method Str(Backtrace:D:)

Returns a concise string representation of the backtrace, omitting routines marked as is hidden-from-backtrace, and at the discretion of the implementation, also some routines from the setting.

my $backtrace = Backtrace.new;
say $backtrace.Str;

Class: DateTime §

From DateTime

(DateTime) method Str §

Defined as:

method Str(DateTime:D: --> Str:D)

Returns a string representation of the invocant, as done by the formatter. If no formatter was specified, an ISO 8601 timestamp will be returned.

say DateTime.new('2015-12-24T12:23:00+0200').Str;
# OUTPUT: «2015-12-24T12:23:00+02:00␤» 

Class: Pair §

From Pair

(Pair) method Str §

Defined as:

multi method Str(Pair:D: --> Str:D)

Returns a string representation of the invocant formatted as key ~ \t ~ value.

my $b = eggs => 3;
say $b.Str;                                       # OUTPUT: «eggs  3␤»

Class: Allomorph §

From Allomorph

(Allomorph) method Str §

method Str(Allomorph:D:)

Returns the Str value of the invocant.

Class: IO::CatHandle §

From IO::CatHandle

(IO::CatHandle) method Str §

Defined as:

method Str(IO::CatHandle:D: --> Str:D)

Calls .Str on the currently active source handle and returns the result. If the source handle queue has been exhausted, returns an implementation-defined string ('<closed IO::CatHandle>' in Rakudo).

Class: IO::Handle §

From IO::Handle

(IO::Handle) method Str §

Returns the value of .path, coerced to Str.

say "foo".IO.open.Str# OUTPUT: «foo␤» 

Class: IO::Path §

From IO::Path

(IO::Path) method Str §

Defined as:

method Str(IO::Path:D: --> Str)

Alias for IO::Path.path. In particular, note that default stringification of an IO::Path does NOT use the value of $.CWD attribute. To stringify while retaining full path information use .absolute or .relative methods.

Class: IO::Special §

From IO::Special

(IO::Special) method Str §

method Str(IO::Special:D:)

This returns '<STDIN>', '<STDOUT>', or '<STDERR>' as appropriate.

Class: Num §

From Num

(Num) method Str §

method Str(Int:D)

Returns a string representation of the number.

say π.Str;                # OUTPUT: «3.141592653589793␤»

Cool being a parent class of Num, an explicit call to the Num.Str method is seldom needed.

say π.Str.comb == π.comb# OUTPUT: «True␤»

Class: ForeignCode §

From ForeignCode

(ForeignCode) method Str §

method StrForeignCode:D: )

Returns the name of the code by calling name.

Class: Junction §

From Junction

(Junction) method Str §

Defined as:

multi method Str(Junction:D:)

Autothreads the .Str method over its elements and returns results as a Junction. Output methods that use .Str method (print and put) are special-cased to autothread junctions, despite being able to accept a Mu type.

Class: Code §

From Code

(Code) method Str §

Defined as:

multi method Str(Code:D: --> Str:D)

Will output the method name, but also produce a warning. Use .raku or .gist instead.

sub marine() { }
say ~&marine;
# OUTPUT: «Sub object coerced to string (please use .gist or .raku to do that)␤marine␤» 
say &marine.Str;
# OUTPUT: «Sub object coerced to string (please use .gist or .raku to do that)␤marine␤» 
say &marine.raku# OUTPUT: «sub marine { #`(Sub|94280758332168) ... }␤»

Role: Systemic §

From Systemic

(Systemic) method Str §

method Str

Instance method returning the name of the object.

say $*RAKU.Str# OUTPUT: «Raku␤»

Class: Label §

From Label

(Label) method Str §

Converts to a string including the name, file and line it's been defined in.

Role: Real §

From Real

(Real) method Str §

multi method Str(Real:D:)

Calls the Bridge method on the invocant and then the Str method on its return value.

Class: StrDistance §

From StrDistance

(StrDistance) method Str §

Defined as:

multi method Str(StrDistance:D: --> Str)

Returns an after string value.

my $str-dist = ($str ~~ tr/old/new/);
say $str-dist.Str# OUTPUT: «fnew␤» 
say ~$str-dist;    # OUTPUT: «fnew␤» 

Class: Version §

From Version

(Version) method Str §

method Str(Version:D: --> Str:D)

Returns a string representation of the invocant.

my $v1 = v1.0.1;
my $v2 = Version.new('1.0.1');
say $v1.Str;                                      # OUTPUT: «1.0.1␤» 
say $v2.Str;                                      # OUTPUT: «1.0.1␤»

Class: Match §

From Match

(Match) method Str §

Defined as:

method Str(Match:D: --> Str:D)

Returns the matched text.

"abc123def" ~~ /\d+/;
say $/.Str;               # OUTPUT: «123␤»