unified format

 and add note about default constructor

Author: tisonkun

doc/Language/objects.pod6

@@ -112,7 +112,7 @@ sub f($x) {
     ...
 }
 
-Subtype checking is done by X<smart-matching|smartmatch operator>:
+Subtype checking is done by L<smart-matching|smart-match operator>:
 
 =for code :preamble<my $type;>
 if $type ~~ Real {
@@ -124,15 +124,13 @@ if $type ~~ Real {
 Classes are declared using the C<class> keyword, typically followed by a
 name.
 
-    class Journey {
-    }
+    class Journey { }
 
 This declaration results in a type object being created and installed in the
 current package and current lexical scope under the name C<Journey>.  You
 can also declare classes lexically:
 
-    my class Journey {
-    }
+    my class Journey { }
 
 This restricts their visibility to the current lexical scope, which can be
 useful if the class is an implementation detail nested inside a module or
@@ -179,8 +177,9 @@ and C<.notes> will all be accessible from outside the class, but only
 C<.notes> can be modified.
 
 If an object is instantiated without certain attributes, such as origin or
-destination, we may not get the desired result . To prevent this, provide default values or make
-sure that an attribute is set on object creation by marking an attribute with an L<is required> trait.
+destination, we may not get the desired result. To prevent this, provide
+default values or make sure that an attribute is set on object creation
+by marking an attribute with an L<is required> trait.
 
     class Journey {
         # error if origin is not provided
@@ -195,10 +194,10 @@ Since classes inherit a default constructor from C<Mu> and we have requested
 that some accessor methods are generated for us, our class is already
 somewhat functional.
 
-    =begin code :allow<B L> :preamble<class Journey {};>
+    =begin code :preamble<class Journey {};>
     # Create a new instance of the class.
     my $vacation = Journey.new(
-        origin      L«=>» 'Sweden',
+        origin      => 'Sweden',
         destination => 'Switzerland',
         notes       => 'Pack hiking gear!'
     );
@@ -210,30 +209,32 @@ somewhat functional.
     $vacation.notes = 'Pack hiking gear and sunglasses!';
     =end code
 
-Note that the default constructor will only set attributes that have an
-accessor method, but it can initialize read-only attributes.
+Note that, although the default constructor can initialize read-only
+attributes, it will only set attributes that have an accessor method.
+That is, even if you pass C«travelers => ["Alex", "Betty"]» to the
+default constructor, the attribute C<@!travelers> is not initialized.
 
 =head2 Methods
 
 Methods are declared with the C<method> keyword inside a class body.
 
-    =begin code :allow<B L>
+    =begin code
     class Journey {
         has $.origin;
         has $.destination;
         has @!travelers;
         has $.notes is rw;
 
-        B<method> add_traveler($name) {
-            if $name L<ne> L<any>(@!travelers) {
-                L<push> @!travelers, $name;
+        method add-traveler($name) {
+            if $name ne any(@!travelers) {
+                push @!travelers, $name;
             }
             else {
-                L<warn> "$name is already going on the journey!";
+                warn "$name is already going on the journey!";
             }
         }
 
-        B<method> describe() {
+        method describe() {
             "From $!origin to $!destination"
         }
     }
@@ -246,11 +247,10 @@ declares a C<!> twigil and generates an accessor method.
 
 Looking at the code above,
 there is a subtle but important difference between using C<$!origin>
-and C<$.origin> in the method C<describe>. The first is always a lookup of the
-attribute. The first is an inexpensive and obvious lookup of the attribute.
-C<$.origin> is a method call and thus may
-be overridden in a subclass. Only use C<$.origin> if you want to
-allow overriding.
+and C<$.origin> in the method C<describe>.
+C<$!origin> is an inexpensive and obvious lookup of the attribute.
+C<$.origin> is a method call and thus may be overridden in a subclass.
+Only use C<$.origin> if you want to allow overriding.
 
 Unlike Subroutines, additional named arguments will not produce compile time or
 runtime errors. That allows chaining of methods via