routine gist

Table of Contents
1	class Exception
1.1	(Exception) method gist
2	class IO::Handle
2.1	(IO::Handle) method gist
3	class IO::Notification::Change
3.1	(IO::Notification::Change) method gist
4	class IO::Path
4.1	(IO::Path) method gist
5	role Blob
5.1	(Blob) method gist
6	class ForeignCode
6.1	(ForeignCode) method gist
7	class Date
7.1	(Date) method gist
8	class Submethod
8.1	(Submethod) method gist
9	class Nil
9.1	(Nil) method gist
10	class Version
10.1	(Version) method gist
11	class Backtrace
11.1	(Backtrace) method gist
12	role Systemic
12.1	(Systemic) method gist
13	class Map
13.1	(Map) method gist
14	class List
14.1	(List) method gist
15	role Sequence
15.1	(Sequence) method gist
16	class Complex
16.1	(Complex) method gist
17	class Junction
17.1	(Junction) method gist
18	class Array
18.1	(Array) method gist
19	class Attribute
19.1	(Attribute) method gist
20	class Mu
20.1	(Mu) routine gist

Documentation for routine gist assembled from the following types:

class Exception

From Exception

(Exception) method gist

Defined as:

multi method gist(Exception:D:)

Returns whatever the exception printer should produce for this exception. The default implementation returns message and backtrace separated by a newline.

my $e = X::AdHoc.new(payload => "This exception is pretty bad");
try $e.throw;
if ($!) { say $!.gist; };
# OUTPUT: «This exception is pretty bad
#   in block <unit> at <unknown file> line 1␤»

class IO::Handle

From IO::Handle

(IO::Handle) method gist

Defined as:

method gist(IO::Handle:D: --> Str:D)

Returns a string containing information which .path, if any, the handle is created for and whether it is .opened.

say IO::Handle.new; # IO::Handle<(Any)>(closed)
say "foo".IO.open;  # IO::Handle<"foo".IO>(opened)

class IO::Notification::Change

From IO::Notification::Change

(IO::Notification::Change) method gist

Defined as:

multi method gist(IO::Notification::Change:D:)

Returns the path and event attributes, separated by semicolon.

class IO::Path

From IO::Path

(IO::Path) method gist

Defined as:

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

Returns a string, part of which contains either the value of .absolute (if path is absolute) or .path. Note that no escaping of special characters is made, so e.g. "\b" means a path contains a backslash and letter "b", not a backspace.

say "foo/bar".IO;                       # OUTPUT: «"foo/bar".IO␤»
say IO::Path::Win32.new: ｢C:\foo/bar\｣; # OUTPUT: «"C:\foo/bar\".IO␤»

role Blob

From Blob

(Blob) method gist

Defined as:

method gist(Blob:D: --> Str:D)

Returns the string containing the "gist" of the Blob, listing up to the first 100 elements, separated by space, appending an ellipsis if the Blob has more than 100 elements.

put Blob.new(1, 2, 3).gist; # OUTPUT: «Blob:0x<01 02 03>␤»
put Blob.new(1..2000).gist;
# OUTPUT:
# Blob:0x<01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15
# 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C
# 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43
# 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A
# 5B 5C 5D 5E 5F 60 61 62 63 64 ...>

class ForeignCode

From ForeignCode

(ForeignCode) method gist

method gist( ForeignCode:D: )

Returns the name of the code by calling name.

class Date

From Date

(Date) method gist

Defined as:

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

Returns the date in YYYY-MM-DD format (ISO 8601)

say Date.new('2015-12-24').gist;                    # OUTPUT: «2015-12-24␤»

class Submethod

From Submethod

(Submethod) method gist

Defined as:

multi method gist(Submethod:D:)

Returns the name of the submethod.

class Nil

From Nil

(Nil) method gist

method gist(--> Str:D)

Returns "Nil".

class Version

From Version

(Version) method gist

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

Returns a string representation of the invocant, just like Str, prepended with a lower-case v.

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

class Backtrace

From Backtrace

(Backtrace) method gist

Defined as:

multi method gist(Backtrace:D:)

Returns string "Backtrace(42 frames)" where the number indicates the number of frames available via list method.

role Systemic

From Systemic

(Systemic) method gist

method gist( Systemic:D: )

Instance method returning the name and version of the object.

say $*RAKU.gist; # OUTPUT: «Raku (6.d)␤»

$*RAKU is an object of the Raku type, which mixes in this role and thus implements this method.

class Map

From Map

(Map) method gist

Defined as:

method gist(Map:D: --> Str:D)

Returns the string containing the "gist" of the Map, sorts the pairs and lists up to the first 100, appending an ellipsis if the Map has more than 100 pairs.

class List

From List

(List) method gist

Defined as:

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

Returns the string containing the parenthesized "gist" of the List, listing up to the first 100 elements, separated by space, appending an ellipsis if the List has more than 100 elements. If List is-lazy, returns string '(...)'

put (1, 2, 3).gist;   # OUTPUT «(1 2 3)␤»
put (1..∞).List.gist; # OUTPUT «(...)␤»

put (1..200).List.gist;
# OUTPUT:
# (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
# 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
# 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
# 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
# 96 97 98 99 100 ...)

role Sequence

From Sequence

(Sequence) method gist

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

Returns the gist of the cached sequence.

class Complex

From Complex

(Complex) method gist

Defined as:

method gist(Complex:D: --> Str:D)

Returns a string representation of the form "1+2i", without internal spaces. (Str coercion also returns this.)

say (1-4i).gist;                # OUTPUT: «1-4i␤»

class Junction

From Junction

(Junction) method gist

Defined as:

multi method gist(Junction:D:)

Collapses the Junction and returns a Str composed of the type of the junction and the gists of its components:

<a 42 c>.all.say; # OUTPUT: «all(a, 42, c)␤»

class Array

From Array

(Array) method gist

Exactly the same as List.gist, except using square brackets for surrounding delimiters.

class Attribute

From Attribute

(Attribute) method gist

Defined as

multi method gist(Attribute:D:)

Returns the name of the type followed by the name of the attribute.

class Hero {
    has @!inventory;
    has Str $.name;
    submethod BUILD( :$name, :@inventory ) {
        $!name = $name;
        @!inventory = @inventory
    }
}
say Hero.^attributes(:local)[0]; # OUTPUT: «Positional @!inventory»

Since say implicitly calls .gist, that is what produces the output here.

class Mu

From Mu

(Mu) routine gist

multi sub    gist(+args --> Str)
multi method gist(   --> Str)

Returns a string representation of the invocant, optimized for fast recognition by humans. As such lists will be truncated at 100 elements. Use .raku to get all elements.

The default gist method in Mu re-dispatches to the perl method for defined invocants, and returns the type name in parenthesis for type object invocants. Many built-in classes override the case of instances to something more specific that may truncate output.

gist is the method that say calls implicitly, so say $something and say $something.gist generally produce the same output.

say Mu.gist;        # OUTPUT: «(Mu)␤»
say Mu.new.gist;    # OUTPUT: «Mu.new␤»