Don't use .WHAT, use ^name

coke · coke · commit 138208cef7e2 · 2017-07-26T22:07:57.000-04:00
Part of #1355
diff --git a/doc/Language/containers.pod6 b/doc/Language/containers.pod6
@@ -191,7 +191,7 @@ you can assign a non-array value to an array variable.
 To place a non-C<Array> into an array variable, binding works:
 
     my @a := (1, 2, 3);
-    say @a.WHAT;                # OUTPUT: «(List)␤»
+    say @a.^name;               # OUTPUT: «List␤»
 
 =head1 Binding to array elements
 
diff --git a/doc/Language/exceptions.pod6 b/doc/Language/exceptions.pod6
@@ -62,7 +62,7 @@ To handle all exceptions, use a C<default> statement.
 
    CATCH {
         default {
-            say .WHAT.perl, do given .backtrace[0] { .file, .line, .subname }
+            say .^name, do given .backtrace[0] { .file, .line, .subname }
         }
    }
 
diff --git a/doc/Language/faq.pod6 b/doc/Language/faq.pod6
@@ -313,11 +313,11 @@ can also contain arrays directly:
 
     my @a = 1, 2, 3;
     say @a;                 # OUTPUT: «[1 2 3]␤»
-    say @a.WHAT;            # OUTPUT: «(Array)␤»
+    say @a.^name;           # OUTPUT: «Array␤»
 
     my $scalar = @a;
     say $scalar;            # OUTPUT: «[1 2 3]␤»
-    say $scalar.WHAT;       # OUTPUT: «(Array)␤»
+    say $scalar.^name;      # OUTPUT: «Array␤»
 
 The big difference is that arrays inside a scalar act as one value in list
 context, whereas arrays will be happily iterated over.
diff --git a/doc/Language/functions.pod6 b/doc/Language/functions.pod6
@@ -300,8 +300,8 @@ with. Parameter defaults and type coercions will work but are not passed on.
 
 =for code :skip-test
 proto mistake-proto(Str() $str, Int $number = 42) {*}
-multi mistake-proto($str, $number) { say $str.WHAT }
-mistake-proto(7, 42);  # OUTPUT: «(Int)␤» -- not passed on
+multi mistake-proto($str, $number) { say $str.^name }
+mistake-proto(7, 42);  # OUTPUT: «Int␤» -- not passed on
 mistake-proto('test'); # fails -- not passed on
 
 =comment only
@@ -839,8 +839,8 @@ class Bar {
 }
 
 sub print-bar(Bar() $bar) {
-   say $bar.WHAT; # OUTPUT: «(Bar)␤»
-   say $bar.msg;  # OUTPUT: «I'm a foo! But I am now Bar.␤»
+   say $bar.^name; # OUTPUT: «Bar␤»
+   say $bar.msg;   # OUTPUT: «I'm a foo! But I am now Bar.␤»
 }
 
 print-bar Foo.new;
diff --git a/doc/Language/glossary.pod6 b/doc/Language/glossary.pod6
@@ -85,9 +85,9 @@ The I<allomorph> types L<IntStr|/type/IntStr>, L<NumStr|/type/NumStr>,
 L<RatStr|/type/RatStr> and L<ComplexStr|/type/ComplexStr> may be created
 as a result of parsing a quoted string:
 
-    say <42>.WHAT;     # OUTPUT: «(IntStr)␤»
-    say <42.1e0>.WHAT; # OUTPUT: «(NumStr)␤»
-    say <42.1>.WHAT;   # OUTPUT: «(RatStr)␤»
+    say <42>.^name;     # OUTPUT: «IntStr␤»
+    say <42.1e0>.^name; # OUTPUT: «NumStr␤»
+    say <42.1>.^name;   # OUTPUT: «RatStr␤»
 
 Note: angle brackets can also be used to create literals for which you'd
 normally need to use some operator (e.g. C</> for L<Rat> or C<+> for
@@ -103,10 +103,10 @@ expressions are not allowed, for example, as literals in signatures:
 If you I<do> want an allomorph and not a literal L<Numeric>,
 then include whitespace around angle brackets:
 
-    say <42/1>.WHAT;   # OUTPUT: «(Rat)␤»
-    say <42+0i>.WHAT;  # OUTPUT: «(Complex)␤»
-    say < 42+0i >.WHAT;# OUTPUT: «(ComplexStr)␤»
-    say < 42/1 >.WHAT; # OUTPUT: «(RatStr)␤»
+    say <42/1>.^name;    # OUTPUT: «Rat␤»
+    say <42+0i>.^name;   # OUTPUT: «Complex␤»
+    say < 42+0i >.^name; # OUTPUT: «ComplexStr␤»
+    say < 42/1 >.^name;  # OUTPUT: «RatStr␤»
 
 =head1 Anonymous
 X<|Anonymous>
diff --git a/doc/Language/objects.pod6 b/doc/Language/objects.pod6
@@ -82,12 +82,13 @@ Types themselves are objects and you can get the I<type object> by writing its n
 You can ask any object for its type object by calling the C<WHAT> method
 (which is actually a macro in method form):
 
+=for code :ok-test<WHAT>
     my $int-type-obj = 1.WHAT;
 
 Type objects (other than L<Mu>) can be compared for equality with the
 L<C<===>|===> identity operator:
 
-=begin code :allow<B L>
+=begin code :allow<B L> :ok-test<WHAT>
 
 sub f(Int $x) {
     if $x.WHAT B<L<===>> Int {
diff --git a/doc/Language/subscripts.pod6 b/doc/Language/subscripts.pod6
@@ -661,7 +661,7 @@ behavior, can be indexed like a hash:
 
     =begin code
     my $request = HTTP::Request.new(GET => "perl6.org");
-    say $request.header.WHAT;  # OUTPUT: «(HTTP::Header)␤»
+    say $request.header.^name;  # OUTPUT: «HTTP::Header␤»
 
     $request.header<Accept> = "text/plain";
     $request.header{'Accept-' X~ <Charset Encoding Language>} = <utf-8 gzip en>;
diff --git a/doc/Language/typesystem.pod6 b/doc/Language/typesystem.pod6
@@ -23,8 +23,8 @@ L<parameters|/type/Signature#Type_Constraints> and return types.
 
     my $a = 1;
     $a = Nil;
-    say $a.WHAT;
-    # OUTPUT: «(Any)␤»
+    say $a.^name;
+    # OUTPUT: «Any␤»
 
     class C {};
     say C.^parents(:all);
@@ -40,9 +40,11 @@ To test if an object is a type object, test for definedness and check for
 identity between the object and its C<.WHAT> pseudo-method. Note that the
 method C<.defined> can be overloaded and may provide false information.
 
+=begin code :ok-test<WHAT>
     my $a = Int;
     say so $a // $a === $a.WHAT;
     # OUTPUT: «True␤»
+=end code
 
 =head3 Undefinedness
 
@@ -272,12 +274,14 @@ compiler, namely C<WHAT>, C<WHO>, C<HOW> and C<VAR>. Declaring methods with
 those names will silently fail. A dynamic call will work, what allows to call
 methods from foreign objects.
 
+=begin code :ok-test<WHAT>
     class A {
         method WHAT { "ain't gonna happen" }
     };
 
     say A.new.WHAT;    # OUTPUT: «(A)␤»
     say A.new."WHAT"() # OUTPUT: «ain't gonna happen␤»
+=end code
 
 =head4 Methods in package scope
 
@@ -697,7 +701,7 @@ value types C<Numerical> and C<Str> are supported.
     say same(name1, name2); # OUTPUT: «False␤»
     my $a = name1;
     say $a ~~ Names; # OUTPUT: «True␤»
-    say $a.WHAT;     # OUTPUT: «(Names)␤»
+    say $a.^name;    # OUTPUT: «Names␤»
 
 All keys have to be of the same type.
 
@@ -721,9 +725,9 @@ Enums can be anonymous. There will be no type created, resulting in a lack of
 introspectiveness. The returned object is of type C<Map>.
 
     my $e = enum <one two three>;
-    say two;      # OUTPUT: «two␤»
-    say one.WHAT; # OUTPUT: «()␤»
-    say $e.WHAT;  # OUTPUT: «(Map)␤»
+    say two;       # OUTPUT: «two␤»
+    say one.^name; # OUTPUT: «␤»
+    say $e.^name;  # OUTPUT: «Map␤»
 
 There are various methods to get access to keys and values. All of them turn the
 values into C<Str>, which may not be desirable. By treating the enum as a
diff --git a/doc/Language/variables.pod6 b/doc/Language/variables.pod6
@@ -80,11 +80,11 @@ seen in the current expression or declarator:
     say $foo.perl;          # OUTPUT: «5␤»
 
     my @bar = 7, 9;         # list assignment
-    say @bar.WHAT;          # OUTPUT: «(Array)␤»
+    say @bar.^name;         # OUTPUT: «Array␤»
     say @bar.perl;          # OUTPUT: «[7, 9]␤»
 
     (my $baz) = 11, 13;     # list assignment
-    say $baz.WHAT;          # OUTPUT: «(List)␤»
+    say $baz.^name;         # OUTPUT: «List␤»
     say $baz.perl;          # OUTPUT: «$(11, 13)␤»
 
 Thus, the behavior of an assignment contained within a list assignment depends
diff --git a/doc/Type/Baggy.pod6 b/doc/Type/Baggy.pod6
@@ -391,8 +391,8 @@ are the keys and their respective weights the values.
 
     my $breakfast = bag <eggs bacon bacon>;
     my $h = $breakfast.hash;
-    say $h.WHAT;                                      # OUTPUT: «(Hash[Any,Any])␤»
-    say $h;                                           # OUTPUT: «{bacon => 2, eggs => 1}␤»
+    say $h.^name;                    # OUTPUT: «Hash[Any,Any]␤»
+    say $h;                          # OUTPUT: «{bacon => 2, eggs => 1}␤»
 
 =head2 method Bool
 
@@ -428,8 +428,8 @@ Returns a L<SetHash|/type/SetHash> whose elements are the L<keys|#method keys> o
 
     my $breakfast = (eggs => 2, bacon => 3).BagHash;
     my $sh = $breakfast.SetHash;
-    say $sh.WHAT;                                     # OUTPUT: «(SetHash)␤»
-    say $sh.elems;                                    # OUTPUT: «2␤»
+    say $sh.^name;                            # OUTPUT: «SetHash␤»
+    say $sh.elems;                            # OUTPUT: «2␤»
 
 =head2 method ACCEPTS
 
diff --git a/doc/Type/Block.pod6 b/doc/Type/Block.pod6
@@ -13,7 +13,7 @@ Without an explicit signature or placeholder arguments, a block has C<$_>
 as a positional argument
 
     my $block = { uc $_; };
-    say $block.WHAT;            # OUTPUT: «(Block)␤»
+    say $block.^name;           # OUTPUT: «Block␤»
     say $block('hello');        # OUTPUT: «HELLO␤»
 
 A block can have a L<Signature|/type/Signature> between C<< -> >> or C<< <-> >>
diff --git a/doc/Type/ComplexStr.pod6 b/doc/Type/ComplexStr.pod6
@@ -11,7 +11,7 @@ allow for the representation of a value as both a string and a numeric type, typ
 they will be created for you when the context is "stringy" but they can be determined
 to be numbers, such as in some L<quoting constructs|/language/quoting>:
 
-    my $f = <42+0i>; say $f.WHAT; # OUTPUT: «(ComplexStr)␤»
+    my $f = <42+0i>; say $f.^name; # OUTPUT: «ComplexStr␤»
 
 As a subclass of both L«C<Complex>|/type/Complex» and L«C<Str>|/type/Str»,
 a C<ComplexStr> will be accepted where either is expected. However,
diff --git a/doc/Type/Dateish.pod6 b/doc/Type/Dateish.pod6
@@ -61,10 +61,10 @@ L<DateTime method Str|/type/DateTime#method Str> with the
 invocant as its only argument.
 
     my $dt = Date.new('2015-12-31');  # (no formatter specified)
-    say $dt.formatter.WHAT;           # OUTPUT: «(Callable)␤»
+    say $dt.formatter.^name;          # OUTPUT: «Callable␤»
     my $us-format = sub ($self) { sprintf "%02d/%02d/%04d", .month, .day, .year given $self; };
     $dt = Date.new('2015-12-31', formatter => $us-format);
-    say $dt.formatter.WHAT;           # OUTPUT: «(Sub)␤»
+    say $dt.formatter.^name;           # OUTPUT: «Sub␤»
     say $dt;                          # OUTPUT: «12/31/2015␤»
 
 =head2 method is-leap-year
diff --git a/doc/Type/Hash.pod6 b/doc/Type/Hash.pod6
@@ -51,7 +51,7 @@ If a L<Pair> is encountered where a value is expected, it is used as a
 hash value:
 
     my %h = 'a', 'b' => 'c';
-    say %h<a>.WHAT;             # OUTPUT: «(Pair)␤»
+    say %h<a>.^name;            # OUTPUT: «Pair␤»
     say %h<a>.key;              # OUTPUT: «b␤»
 
 If the same key appears more than once, the value associated with its last
@@ -64,7 +64,7 @@ To assign a hash to a variable which does not have the C<%> sigil, you may use t
 constructor:
 
     my $h = %( a => 1, b => 2 );
-    say $h.WHAT;                # OUTPUT: «(Hash)␤»
+    say $h.^name;               # OUTPUT: «Hash␤»
     say $h<a>;                  # OUTPUT: «1␤»
 
 B<NOTE:> Hashes can also be constructed with C<{ }> similarly to how they are
@@ -88,11 +88,11 @@ sub lookup-user (Hash $h) { #`(Do something...) $h }
 my @names = map {
     # While this creates a hash:
     my $query = { name => "$person<firstName> $person<lastName>" };
-    say $query.WHAT;     # OUTPUT: «(Hash)␤»
+    say $query.^name;      # OUTPUT: «Hash␤»
     # And this also makes a hash
     # Doing this will create a Block. Oh no!
     my $query = { name => "$_<firstName> $_<lastName>" };
-    say $query2.WHAT;       # OUTPUT: «(Block)␤»
+    say $query2.^name;       # OUTPUT: «Block␤»
     say $query2<name>;      # fails
 
     CATCH { default { put .^name, ': ', .Str } };
diff --git a/doc/Type/IntStr.pod6 b/doc/Type/IntStr.pod6
@@ -11,7 +11,7 @@ allow for the representation of a value as both a string and a numeric type, typ
 they will be created for you when the context is "stringy" but they can be determined
 to be numbers, such as in some L<quoting constructs|/language/quoting>:
 
-    my $f = <42>; say $f.WHAT; # OUTPUT: «(IntStr)␤»
+    my $f = <42>; say $f.^name; # OUTPUT: «IntStr␤»
 
 As a subclass of both L«C<Int>|/type/Int» and L«C<Str>|/type/Str», an C<IntStr>
 will be accepted where either is expected. However, C<IntStr> does not share
diff --git a/doc/Type/List.pod6 b/doc/Type/List.pod6
@@ -126,8 +126,8 @@ Defined as:
 
 Returns a sequence of the list elements, in order.
 
-    say (1,2,3,4).WHAT;        # OUTPUT: «(List)␤»
-    say (1,2,3,4).values.WHAT; # OUTPUT: «(Seq)␤»
+    say (1,2,3,4).^name;        # OUTPUT: «List␤»
+    say (1,2,3,4).values.^name; # OUTPUT: «Seq␤»
 
 =head2 routine kv
 
@@ -192,7 +192,7 @@ Invokes C<&code> for each element and gathers the return values in a sequence
     and returns it. This happens lazily, i.e. C<&code> is only invoked when the
 return values are accessed.Examples:
 
-    say ('hello', 1, 22/7, 42, 'world').map: { .WHAT.perl } # OUTPUT: «(Str Int Rat Int Str)␤»
+    say ('hello', 1, 22/7, 42, 'world').map: { .^name } # OUTPUT: «(Str Int Rat Int Str)␤»
     say map *.Str.chars, 'hello', 1, 22/7, 42, 'world';     # OUTPUT: «(5 1 8 2 5)␤»
 
 C<map> inspects the arity of the code object, and tries to pass as many
diff --git a/doc/Type/NumStr.pod6 b/doc/Type/NumStr.pod6
@@ -11,7 +11,7 @@ allow for the representation of a value as both a string and a numeric type, typ
 they will be created for you when the context is "stringy" but they can be determined
 to be numbers, such as in some L<quoting constructs|/language/quoting>:
 
-    my $f = <42.1e0>; say $f.WHAT; # OUTPUT: «(NumStr)␤»
+    my $f = <42.1e0>; say $f.^name; # OUTPUT: «NumStr␤»
 
 As a subclass of both L«C<Num>|/type/Num» and L«C<Str>|/type/Str», a C<NumStr>
 will be accepted where either is expected. However, C<NumStr> does not share
diff --git a/doc/Type/Pair.pod6 b/doc/Type/Pair.pod6
@@ -35,12 +35,12 @@ on context you may have to be explicit when assigning colon lists.
     # OUTPUT: «{:a1, :b2}␤»
 
     my $manna = :a1:b2:c3;
-    say $manna.WHAT;
-    # OUTPUT: «(Pair)␤»
+    say $manna.^name;
+    # OUTPUT: «Pair␤»
 
     $manna = (:a1:b2:c3);
-    say $manna.WHAT;
-    # OUTPUT: «(List)␤»
+    say $manna.^name;
+    # OUTPUT: «List␤»
 
 Any variable can be turned into a C<Pair> of its name and its value.
 
@@ -176,8 +176,8 @@ Defined as:
 Returns a list of one C<Pair>, namely this one.
 
     my $p = (Perl => 6);
-    say $p.pairs.WHAT; # OUTPUT: «(List)␤»
-    say $p.pairs[0];   # OUTPUT: «Perl => 6␤»
+    say $p.pairs.^name; # OUTPUT: «List␤»
+    say $p.pairs[0];    # OUTPUT: «Perl => 6␤»
 
 =head2 method antipairs
 
@@ -189,9 +189,9 @@ Returns a L<List|/type/List> containing the L<antipair|/type/Pair#method_antipai
 of the invocant.
 
     my $p = (6 => 'Perl').antipairs;
-    say $p.WHAT;                                      # OUTPUT: «(List)␤»
+    say $p.^name;                                     # OUTPUT: «List␤»
     say $p.first;                                     # OUTPUT: «Perl => 6␤»
-    say $p.first.WHAT;                                # OUTPUT: «(Pair)␤»
+    say $p.first.^name;                               # OUTPUT: «Pair␤»
 
 =head2 method invert
 
diff --git a/doc/Type/Parameter.pod6 b/doc/Type/Parameter.pod6
@@ -250,9 +250,10 @@ parameter.  Type captures define a type name within the attached code,
 which is an alias to the type gleaned from the argument during a call.
 
     sub a(::T ::U $x) { T.say }
+    a(8);                                       # OUTPUT: «(Int)␤»
+    say &a.signature.params[0].type_captures;   # OUTPUT: «(T U)␤»
+    sub b($x) { $x.^name.say }
     a(8);                                       # OUTPUT: «Int␤»
-    say &a.signature.params[0].type_captures;   # OUTPUT: «T U␤»
-    sub b($x) { $x.WHAT.say }                   # does the same thing, but uglier.
 
 The type used may change from call to call.  Once they are defined,
 type captures can be used wherever you would use a type, even later
diff --git a/doc/Type/Rat.pod6 b/doc/Type/Rat.pod6
@@ -28,8 +28,8 @@ the denominator quickly:
         $x = ($x + $n / $x) / 2 for ^$iterations;
         return $x;
     }
-    say approx-sqrt(2, 5).WHAT;     # OUTPUT: «(Rat)␤»
-    say approx-sqrt(2, 10).WHAT;    # OUTPUT: «(Num)␤»
+    say approx-sqrt(2, 5).^name;     # OUTPUT: «Rat␤»
+    say approx-sqrt(2, 10).^name;    # OUTPUT: «Num␤»
 
 If you want arbitrary precision arithmetic with rational numbers, use the
 L<FatRat|/type/FatRat> type instead.
diff --git a/doc/Type/RatStr.pod6 b/doc/Type/RatStr.pod6
@@ -11,7 +11,7 @@ allow for the representation of a value as both a string and a numeric type, typ
 they will be created for you when the context is "stringy" but they can be determined
 to be numbers, such as in some L<quoting constructs|/language/quoting>:
 
-    my $f = <42.1>; say $f.WHAT; # OUTPUT: «(RatStr)␤»
+    my $f = <42.1>; say $f.^name; # OUTPUT: «RatStr␤»
 
 As a subclass of both L«C<Rat>|/type/Rat» and L«C<Str>|/type/Str», a C<RatStr>
 will be accepted where either is expected. However, C<RatStr> does not share
diff --git a/doc/Type/Regex.pod6 b/doc/Type/Regex.pod6
@@ -23,7 +23,7 @@ definition in curly braces. Since any regex does C<Callable> introspection requi
 referencing via C<&>-sigil.
 
     my regex R { \N };
-    say &R.WHAT; # OUTPUT: «(Regex)␤»
+    say &R.^name; # OUTPUT: «Regex␤»
 
 To match a string against a regex, you can use the smart match operator:
 
diff --git a/doc/Type/Scalar.pod6 b/doc/Type/Scalar.pod6
diff --git a/doc/Type/Signature.pod6 b/doc/Type/Signature.pod6
diff --git a/doc/Type/Str.pod6 b/doc/Type/Str.pod6
diff --git a/doc/Type/Sub.pod6 b/doc/Type/Sub.pod6
diff --git a/doc/Type/UInt.pod6 b/doc/Type/UInt.pod6
diff --git a/doc/Type/Whatever.pod6 b/doc/Type/Whatever.pod6

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ To handle all exceptions, use a C<default> statement.`
`62`	`62`
`63`	`63`	`CATCH {`
`64`	`64`	`default {`
`65`		`- say .WHAT.perl, do given .backtrace[0] { .file, .line, .subname }`
	`65`	`+ say .^name, do given .backtrace[0] { .file, .line, .subname }`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`