Unified format of code block

and delete redundant links

Author: tisonkun

doc/Language/objects.pod6

@@ -22,29 +22,33 @@ object. That includes literals, types (type objects), code and containers.
 
 To call a method on an object, add a dot, followed by the method name:
 
-=for code :allow<B L>
-L<say> "abc"B<.L<uc>>;
+=for code
+say "abc".uc;
 # OUTPUT: «ABC␤»
 
-This calls the L<C<uc>|uc> method on C<"abc">, which is an object of type
-L<C<Str>|Str>. To supply arguments to the method, add arguments inside parentheses
+This calls the C<uc> method on C<"abc">, which is an object of type
+C<Str>. To supply arguments to the method, add arguments inside parentheses
 after the method.
 
-=for code :allow<B L>
-my $formatted-text = "Fourscore and seven years ago...".L<indent>B<(8)>;
+=for code
+my $formatted-text = "Fourscore and seven years ago...".indent(8);
+say $formatted-text;
+# OUTPUT: «        Fourscore and seven years ago...␤»
 
 C<$formatted-text> now contains the above text, but indented 8 spaces.
 
 Multiple arguments are separated by commas:
 
-=for code :allow<B L> :preamble<my $formatted-text;>
+=for code :preamble<my $formatted-text;>
 my @words = "Abe", "Lincoln";
-@words.L<push>("said"B<,> $formatted-text.L<comb>(L</\w+/|/language/regexes>));
+@words.push("said", $formatted-text.comb(/\w+/));
+say @words;
+# OUTPUT: «[Abe Lincoln said (Fourscore and seven years ago)]␤»
 
 Multiple arguments can be specified by separating the argument list with a colon:
 
-=for code :allow<B L> :preamble<my @words;>
-say @words.L<join>: '--';
+=for code :preamble<my @words;>
+say @words.join: '--';
 # OUTPUT: «Abe--Lincoln--said--Fourscore--and--seven--years--ago␤»
 
 Since you have to put a C<:> after the method if you want to pass arguments
@@ -63,12 +67,11 @@ Methods can return mutable containers, in which case you can assign to the
 return value of a method call. This is how read-writable attributes to
 objects are used:
 
-=for code :allow<L>
-$*IN.L<nl-in> = "\r\n";
+=for code
+$*IN.nl-in = "\r\n";
 
 Here, we call method C<nl-in> on the C<$*IN> object, without arguments,
-and assign to the container it returned with the
-L<C<=>|=> operator.
+and assign to the container it returned with the L<C<=>|=> operator.
 
 All objects support methods from class L<Mu>, which is the type hierarchy root.
 All objects derive from C<Mu>.
@@ -77,46 +80,42 @@ All objects derive from C<Mu>.
 
 Types themselves are objects and you can get the I<type object> by writing its name:
 
-    my $int-type-obj = Int;
+=for code
+my $int-type-obj = Int;
 
 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;
+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> :ok-test<WHAT>
-
+=for code :ok-test<WHAT>
 sub f(Int $x) {
-    if $x.WHAT B<L<===>> Int {
+    if $x.WHAT === Int {
         say 'you passed an Int';
     }
     else {
         say 'you passed a subtype of Int';
     }
 }
-=end code
 
 Although, in most cases, the L<C<.isa>|isa> method will suffice:
 
-=begin code :allow<B L>
-
+=for code
 sub f($x) {
-    if $xB<.L<isa>>(Int) {
+    if $x.isa(Int) {
         ...
     }
     ...
 }
 
-=end code
-
-Subtype checking is done by smart-matching:
+Subtype checking is done by X<smart-matching|smartmatch operator>:
 
-=for code :allow<B L> :preamble<my $type;>
-if $type B<L<~~>> L<Real> {
+=for code :preamble<my $type;>
+if $type ~~ Real {
     say '$type contains Real or a subtype thereof';
 }