Merge pull request #1165 from Altai-man/comments

Make comment style the same in Type/ directory

Author: Altai-man

doc/Type/Any.pod6

@@ -41,8 +41,8 @@ Defined as:
 Interprets the invocant as a list and creates an
 C<any>-L<Junction|/type/Junction> from it.
 
-    say so 2 == <1 2 3>.any;        # True
-    say so 5 == <1 2 3>.any;        # False
+    say so 2 == <1 2 3>.any;        # OUTPUT: «True␤»
+    say so 5 == <1 2 3>.any;        # OUTPUT: «False␤»
 
 =head2 method all
 
@@ -53,8 +53,8 @@ Defined as:
 Interprets the invocant as a list and creates an
 C<all>-L<Junction|/type/Junction> from it.
 
-    say so 1 < <2 3 4>.all;         # True
-    say so 3 < <2 3 4>.all;         # False
+    say so 1 < <2 3 4>.all;         # OUTPUT: «True␤»
+    say so 3 < <2 3 4>.all;         # OUTPUT: «False␤»
 
 =head2 method one
 
@@ -65,8 +65,8 @@ Defined as:
 Interprets the invocant as a list and creates a
 C<one>-L<Junction|/type/Junction> from it.
 
-    say so 1 == (1, 2, 3).one;      # True
-    say so 1 == (1, 2, 1).one;      # False
+    say so 1 == (1, 2, 3).one;      # OUTPUT: «True␤»
+    say so 1 == (1, 2, 1).one;      # OUTPUT: «False␤»
 
 =head2 method none
 
@@ -77,15 +77,15 @@ Defined as:
 Interprets the invocant as a list and creates a
 C<none>-L<Junction|/type/Junction> from it.
 
-    say so 1 == (1, 2, 3).none;     # False
-    say so 4 == (1, 2, 3).none;     # True
+    say so 1 == (1, 2, 3).none;     # OUTPUT: «False␤»
+    say so 4 == (1, 2, 3).none;     # OUTPUT: «True␤»
 
 =head2 method list
 
 Interprets the invocant as a list, and returns that L<List|/type/List>.
 
-    say 42.list.^name;           # List
-    say 42.list.elems;           # 1
+    say 42.list.^name;           # OUTPUT: «List␤»
+    say 42.list.elems;           # OUTPUT: «1␤»
 
 =head2 method push
 
@@ -95,9 +95,9 @@ implements C<Positional> already.  The argument provided will then be pushed
 into the newly created Array.
 
     my %h;
-    dd %h<a>; # Any (and therefor undefined)
+    dd %h<a>;      # Any (and therefore undefined)
     %h<a>.push(1); # .push on Any
-    dd %h; # «Hash %h = {:a($[1])}␤» # please note the Array
+    dd %h;         # «Hash %h = {:a($[1])}␤» # please note the Array
 
 =head2 routine reverse
 
@@ -113,19 +113,19 @@ to reverse the characters in a string, use L<flip>.
 
 Examples:
 
-    say <hello world!>.reverse;     # (world! hello)
-    say reverse ^10;                # (9 8 7 6 5 4 3 2 1 0)
+    say <hello world!>.reverse;     # OUTPUT: «(world! hello)␤»
+    say reverse ^10;                # OUTPUT: «(9 8 7 6 5 4 3 2 1 0)␤»
 
 =head2 method sort
 
 Sorts iterables with C<infix:<cmp>> or given code object and returns a new C<List>.
 
 Examples:
 
-    say <b c a>.sort;                           # (a b c)
-    say 'bca'.comb.sort.join;                   # abc
-    say 'bca'.comb.sort({$^b cmp $^a}).join;    # cba
-    say '231'.comb.sort(&infix:«<=>»).join;     # 123
+    say <b c a>.sort;                           # OUTPUT: «(a b c)␤»
+    say 'bca'.comb.sort.join;                   # OUTPUT: «abc␤»
+    say 'bca'.comb.sort({$^b cmp $^a}).join;    # OUTPUT: «cba␤»
+    say '231'.comb.sort(&infix:«<=>»).join;     # OUTPUT: «123␤»
 
 =head2 method map
 
@@ -178,8 +178,8 @@ L<halting problem|https://en.wikipedia.org/wiki/Halting_problem> for you.
 If you flat an infinite list C<.flat> may return that infinite list, eating
 all your RAM in the process.
 
-    say ((1, 2), (3)).elems;        # 2
-    say ((1, 2), (3)).flat.elems;   # 3
+    say ((1, 2), (3)).elems;        # OUTPUT: «2␤»
+    say ((1, 2), (3)).flat.elems;   # OUTPUT: «3␤»
 
 Please not that C<flat> does not recurse into sub lists. You have to recurse by
 hand or reconsider your data structures. A single level of nesting can often be
@@ -188,30 +188,29 @@ signatures. For deeper structures you may consider
 L<gather/take|/syntax/gather take> to create a lazy list.
 
     my @a = [[1,2,3],[[4,5],6,7]];
-    say gather deepmap *.take, @a;
-    # (1 2 3 4 5 6 7)
+    say gather deepmap *.take, @a; # OUTPUT: «(1 2 3 4 5 6 7)␤»
 
 =head2 method eager
 
 Interprets the invocant as a list, evaluates it eagerly, and returns that
 list.
 
-    say (1..10).eager;              # (1 2 3 4 5 6 7 8 9 10)
+    say (1..10).eager;              # OUTPUT: «(1 2 3 4 5 6 7 8 9 10)␤»
 
 =head2 method elems
 
 Interprets the invocant as a list, and returns the number of elements in the
 list.
 
-    say 42.elems;                   # 1
-    say <a b c>.elems;              # 3
+    say 42.elems;                   # OUTPUT: «1␤»
+    say <a b c>.elems;              # OUTPUT: «3␤»
 
 =head2 method end
 
 Interprets the invocant as a list, and returns the last index of that list.
 
-    say 6.end;                      # 0
-    say <a b c>.end;                # 2
+    say 6.end;                      # OUTPUT: «0␤»
+    say <a b c>.end;                # OUTPUT: «2␤»
 
 =head2 method pairup
 
@@ -224,7 +223,7 @@ constructs a pair from them, unless the item in the key position already is a
 pair (in which case the pair is passed is passed through, and the next
 list item, if any, is considered to be a key again).
 
-    say (a => 1, 'b', 'c').pairup.perl;     # (:a(1), :b("c")).Seq
+    say (a => 1, 'b', 'c').pairup.perl;     # OUTPUT: «(:a(1), :b("c")).Seq␤»
 
 =head2 sub exit
 
@@ -247,14 +246,14 @@ Defined as:
 
 Forces given object to be evaluated in item context and returns the value of it.
 
-    say item([1,2,3]).perl;              # $[1, 2, 3]
-    say item({ apple => 10 }).perl;      # ${:apple(10)}
-    say item("abc").perl;                # "abc"
+    say item([1,2,3]).perl;              # OUTPUT: «$[1, 2, 3]␤»
+    say item({ apple => 10 }).perl;      # OUTPUT: «${:apple(10)}␤»
+    say item("abc").perl;                # OUTPUT: «"abc"␤»
 
 You can also use C<$> as item contextualizer.
 
-    say $[1,2,3].perl;                   # $[1, 2, 3]
-    say $("abc").perl;                   # "abc"
+    say $[1,2,3].perl;                   # OUTPUT: «$[1, 2, 3]␤»
+    say $("abc").perl;                   # OUTPUT: «"abc"␤»
 
 =end pod
 

doc/Type/Array.pod6

@@ -46,16 +46,16 @@ Example:
 
     my @foo = <a b c>;
     @foo.push: 'd';
-    say @foo;                   # [a b c d]
+    say @foo;                   # OUTPUT: «[a b c d]␤»
 
 Note that C<push> does not attempt to flatten its argument list.  If you pass
 an array or list as the thing to push, it becomes one additional element:
 
     my @a = <a b c>;
     my @b = <d e f>;
     @a.push: @b;
-    say @a.elems;               # 4
-    say @a[3].join;             # def
+    say @a.elems;               # OUTPUT: «4␤»
+    say @a[3].join;             # OUTPUT: «def␤»
 
 Only if you supply multiple values as separate arguments to C<push> are
 multiple values added to the array:
@@ -64,7 +64,7 @@ multiple values added to the array:
    my @b = <a b>;
    my @c = <E F>;
    @a.push: @b, @c;
-   say @a.elems;                # 3
+   say @a.elems;                # OUTPUT: «3␤»
 
 See L<method append|#method append> for when you want to append multiple
 values that are stored in a single array.
@@ -91,8 +91,8 @@ Example:
     my @a = <a b c>;
     my @b = <d e f>;
     @a.append: @b;
-    say @a.elems;               # 6
-    say @a;                     # [a b c d e f]
+    say @a.elems;               # OUTPUT: «6␤»
+    say @a;                     # OUTPUT: «[a b c d e f]␤»
 
 =head2 routine shift
 
@@ -106,8 +106,8 @@ Removes and returns the first item from the array.  Fails for an empty arrays.
 Example:
 
     my @foo = <a b>;
-    say @foo.shift;             # a
-    say @foo.shift;             # b
+    say @foo.shift;             # OUTPUT: «a␤»
+    say @foo.shift;             # OUTPUT: «b␤»
     say @foo.shift;
     CATCH { default { put .^name, ': ', .Str } };
     # OUTPUT: «X::Cannot::Empty: Cannot shift from an empty Array␤»
@@ -126,7 +126,7 @@ Example:
 
     my @foo = <a b c>;
     @foo.unshift: 1, 3 ... 11;
-    say @foo;                   # [(1 3 5 7 9 11) a b c]
+    say @foo;                   # OUTPUT: «[(1 3 5 7 9 11) a b c]␤»
 
 The notes in L<the documentation for method push|#method push> apply,
 regarding how many elements are added to the array.
@@ -151,7 +151,7 @@ Example:
 
     my @foo = <a b c>;
     @foo.prepend: 1, 3 ... 11;
-    say @foo;                   # [1 3 5 7 9 11 a b c]
+    say @foo;                   # OUTPUT: «[1 3 5 7 9 11 a b c]␤»
 
 =head2 routine splice
 
@@ -181,8 +181,8 @@ C<$start>—and its return value is used the value of C<$elems>.
 Example:
 
     my @foo = <a b c d e f g>;
-    say @foo.splice(2, 3, <M N O P>);        # [c d e]
-    say @foo;                                # [a b M N O P f g]
+    say @foo.splice(2, 3, <M N O P>);        # OUTPUT: «[c d e]␤»
+    say @foo;                                # OUTPUT: «[a b M N O P f g]␤»
 
 =head2 method shape
 
@@ -195,9 +195,9 @@ Returns the shape of the array as a list.
 Example:
 
     my @foo[2;3] = ( < 1 2 3 >, < 4 5 6 > ); # Array with fixed dimensions
-    say @foo.shape;                          # (2 3)
+    say @foo.shape;                          # OUTPUT: «(2 3)␤»
     my @bar = ( < 1 2 3 >, < 4 5 6 > );      # Normal array (of arrays)
-    say @bar.shape;                          # (*)
+    say @bar.shape;                          # OUTPUT: «(*)␤»
 
 =head2 method default
 
@@ -213,14 +213,14 @@ value by using the L<is default|/routine/is default> trait the method returns
 the type object C<(Any)>.
 
     my @a1 = 1, "two", 2.718;
-    say @a1.default;                                       # (Any)
-    say @a1[4];                                            # (Any)
+    say @a1.default;                                       # OUTPUT: «(Any)␤»
+    say @a1[4];                                            # OUTPUT: «(Any)␤»
 
     my @a2 is default(17) = 1, "two", 3;
-    say @a2.default;                                       # 17
-    say @a2[4];                                            # 17
+    say @a2.default;                                       # OUTPUT: «17␤»
+    say @a2[4];                                            # OUTPUT: «17␤»
     @a2[1] = Nil;                                          # (resets element to its default)
-    say @a2[1];                                            # 17
+    say @a2[1];                                            # OUTPUT: «17␤»
 
 =head2 method of
 
@@ -233,10 +233,10 @@ i.e. if no type constraint is given during declaration, the method
 returns C<(Mu)>.
 
     my @a1 = 1, 'two', 3.14159;              # (no type constraint specified)
-    say @a1.of;                              # (Mu)
+    say @a1.of;                              # OUTPUT: «(Mu)␤»
 
     my Int @a2 = 1, 2, 3;                    # (values must be of type Int)
-    say @a2.of;                              # (Int)
+    say @a2.of;                              # OUTPUT: «(Int)␤»
     @a2.push: 'd';
     CATCH { default { put .^name, ': ', .Str } };
     # OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to @a2; expected Int but got Str ("d")␤»

doc/Type/Attribute.pod6

@@ -19,16 +19,16 @@ The usual way to obtain an object of type C<Attribute> is by introspection:
         has @!things;
     }
     my $a = Useless.^attributes(:local)[0];
-    say $a.name;            # @!things
-    say $a.package;         # (Useless)
-    say $a.has_accessor;    # False
+    say $a.name;            # OUTPUT: «@!things␤»
+    say $a.package;         # OUTPUT: «(Useless)␤»
+    say $a.has_accessor;    # OUTPUT: «False␤»
 
     # modifying an attribute from the outside
     # this is usually not possible, but since Attribute
     # is at the level of the meta class, all is fair game
     my $instance = Useless.new;
     $a.set_value($instance, [1, 2, 3]);
-    say $a.get_value($instance);        # [1 2 3]
+    say $a.get_value($instance);        # OUTPUT: «[1 2 3]␤»
 
 =head1 Traits
 

doc/Type/Backtrace/Frame.pod6

@@ -94,6 +94,6 @@ Returns C<True> if the frame is part of a setting.
 
     my $bt = Backtrace.new;
     my $btf = $bt[0];
-    say $btf.is-setting; # True
+    say $btf.is-setting; # OUTPUT: «True␤»
 
 =end pod