Minor typographical etc. corrections to classtut.pod

Author: paultcochrane

lib/Language/classtut.pod

@@ -101,8 +101,8 @@ X<|classes, encapsulation>
 
 The first three lines inside the class block all declare attributes (called
 I<fields> or I<instance storage> in other languages).  These are storage
-locations that every instance of a class will obtain.  Just as a C<my> variable can
-not be accessed from the outside of its declared scope, attributes are not
+locations that every instance of a class will obtain.  Just as a C<my> variable
+cannot be accessed from outside its declared scope, attributes are not
 accessible outside of the class.  This I<encapsulation> is one of the key
 principles of object oriented design.
 
@@ -154,8 +154,8 @@ having to write the method by hand. You are free instead to write your own
 accessor method, if at some future point you need to do something more complex
 than return the value.
 
-Note that using the C<.> twigil has created a method that will provide with
-readonly access to the attribute. If instead the users of this object should be
+Note that using the C<.> twigil has created a method that will provide
+read-only access to the attribute. If instead the users of this object should be
 able to reset a task's completion state (perhaps to perform it again), you can
 change the attribute declaration:
 
@@ -168,8 +168,8 @@ external code can modify to change the value of the attribute.
 
 =head1 Static fields?
 
-Perl 6 has no B<static> keyword. Anyway any class may declare anything that
-module can so making a scoped variable sounds like good idea.
+Perl 6 has no B<static> keyword. Nevertheless any class may declare anything
+that a module can, so making a scoped variable sounds like good idea.
 
        =begin code
 
@@ -184,31 +184,30 @@ module can so making a scoped variable sounds like good idea.
 
        =end code
 
-Class attributes defined by L<my> or L<our> may also be initialized while
-declaration but we are implementing Singleton pattern here and object must
-be created during first use. It is not possible to predict in 100% the moment
-when attribute initialization will be executed  because it can be done during
-compilation, runtime or both especially when importing class using L<use>
-keyword.
+Class attributes defined by L<my> or L<our> may also be initialized when
+being declared, however we are implementing the Singleton pattern here and
+the object must be created during its first use. It is not 100% possible to
+predict the moment when attribute initialization will be executed, because
+it can take place during compilation, runtime or both, especially when
+importing the class using the L<use> keyword.
 
     class HaveStaticAttr {
           my Foo $.foo = some_complicated_subroutine;
     }
 
-Class attributes may also be declared with secondary sigil like object
-attributes that will result in generating read-only accessor if attribute
-is to be public.
-
+Class attributes may also be declared with a secondary sigil -- in a similar
+manner to object attributes -- that will generate read-only accessors if the
+attribute is to be public.
 
 =head1 Methods
 
 X<|methods>
 X<|classes, methods>
 
-While attributes give objects state, methods give objects behaviors.  Ignore
-the C<new> method temporarily; it's a special type of method.  Consider the
-second method, C<add-dependency>, which adds a new task to this task's
-dependency list.
+While attributes give objects state, methods give objects behaviors.  Let's
+ignore the C<new> method temporarily; it's a special type of method.
+Consider the second method, C<add-dependency>, which adds a new task to a
+task's dependency list.
 
     method add-dependency(Task $dependency) {
         push @!dependencies, $dependency;
@@ -222,8 +221,8 @@ the list of methods for the current class.  Thus any instance of the C<Task>
 class can call this method with the C<.> method call operator.  Second, a
 method places its invocant into the special variable C<self>.
 
-The method itself takes the passed parameter--which must be an instance of the
-C<Task> class--and C<push>es it onto the invocant's C<@!dependencies>
+The method itself takes the passed parameter -- which must be an instance of
+the C<Task> class -- and C<push>es it onto the invocant's C<@!dependencies>
 attribute.
 
 The second method contains the main logic of the dependency handler:
@@ -244,7 +243,7 @@ X<|operators, .>
 
 Otherwise, the method performs all of the task's dependencies, using the C<for>
 construct to iterate over all of the items in the C<@!dependencies> attribute.
-This iteration places each item--each a C<Task> object--into the topic
+This iteration places each item -- each a C<Task> object -- into the topic
 variable, C<$_>.  Using the C<.> method call operator without specifying an
 explicit invocant uses the current topic as the invocant.  Thus the iteration
 construct calls the C<.perform()> method on every C<Task> object in the
@@ -275,19 +274,19 @@ X<|objects, bless>
 X<|bless>
 
 The biggest difference between constructors in Perl 6 and constructors in
-languages such as C# and Java is that rather than setting up state on a somehow
-already magically created object, Perl 6 constructors actually create the
-object themselves. This easiest way to do this is by calling the L<bless>
-method, also inherited from L<Mu>. The C<bless> method expects  a set of named parameters providing
-the initial values for each attribute.
+languages such as C# and Java is that rather than setting up state on a
+somehow already magically created object, Perl 6 constructors actually
+create the object themselves. The easiest way to do this is by calling the
+L<bless> method, also inherited from L<Mu>. The C<bless> method expects a
+set of named parameters providing the initial values for each attribute.
 
 The example's constructor turns positional arguments into named arguments, so
 that the class can provide a nice constructor for its users. The first
-parameter is the callback (the thing to do to execute the task). The rest of
+parameter is the callback (the thing which will execute the task). The rest of
 the parameters are dependent C<Task> instances.  The constructor captures these
 into the C<@dependencies> slurpy array and passes them as named parameters to
-C<bless> (note that C<:&callback> uses the name of the variable--minus the
-sigil--as the name of the parameter).
+C<bless> (note that C<:&callback> uses the name of the variable -- minus the
+sigil -- as the name of the parameter).
 
 X<|BUILD>
 
@@ -350,7 +349,7 @@ the various other dependencies in order, giving the output:
 Object Oriented Programming provides the concept of inheritance as one of the
 mechanisms to allow for code reuse.  Perl 6 supports the ability for one class
 to inherit from one or more classes.  When a class inherits from another class
-that informs the method dispatcher to follow the inheritance chain to look
+it informs the method dispatcher to follow the inheritance chain to look
 for a method to dispatch.  This happens both for standard methods defined via
 the method keyword and for methods generated through other means such as
 attribute accessors.
@@ -365,7 +364,6 @@ improved). See L<https://github.com/perl6/book/issues/58> for discussion.
         method pay() {
             say "Here is \$$.salary";
         }
-
     }
 
     class Programmer is Employee {
@@ -393,7 +391,7 @@ defined in the Employee class as though they were from the Programmer class.
     $programmer.pay();
     =end code
 
-=head2 Overriding Inherited Methods
+=head2 Overriding inherited methods
 
 Of course, classes can override methods and attributes defined by parent
 classes by defining their own.  The example below demonstrates the C<Baker> class
@@ -437,18 +435,20 @@ overriding the C<Cook>'s C<cook> method.
 Because the dispatcher will see the C<cook> method on C<Baker> before it moves up to
 the parent class the C<Baker>'s C<cook> method will be called.
 
-As a side node, you might have wondered how passing strings to array attribute
-worked. Array assignment is coercive, so the assignment turn the new value
+As a side note, you might have wondered how passing strings to an array attribute
+worked. Array assignment is coercive, so the assignment turns the new value
 into an array. This mechanism is also used for initializing attributes.
 
-=head2 Multiple Inheritance
+=head2 Multiple inheritance
 
 As mentioned before, a class can inherit from multiple classes.  When a class
 inherits from multiple classes the dispatcher knows to look at both classes when
-looking up a method to search for.  As a side note, Perl 6  uses the C3
-algorithm to linearize the multiple inheritance hierarchies, which is a
+looking up a method to search for.  Perl 6 uses the C3
+algorithm to linearize multiple inheritance hierarchies, which is a
 significant improvement over Perl 5's approach to handling multiple inheritance.
 
+=comment isn't Perl 5 also C3 now?
+
     =begin code
     class GeekCook is Programmer is Cook {
         method new( *%params ) {
@@ -468,10 +468,10 @@ significant improvement over Perl 5's approach to handling multiple inheritance.
     $geek.code_to_solve('P =? NP');
     =end code
 
-Now all the methods made available by both the Programmer class and the Cook
-class are available from the GeekCook class.
+Now all the methods made available to the Programmer and the Cook
+classes are available from the GeekCook class.
 
-While multiple inheritance is a useful concept to know and on occasion of use, it
+While multiple inheritance is a useful concept to know and occasionally use, it
 is important to understand that there are more useful OOP concepts.  When
 reaching for multiple inheritance it is good practice to consider whether the
 design wouldn't be better realized by using roles, which are generally safer
@@ -482,9 +482,9 @@ names.  For more information on roles see A<sec:roles>.
 
 Introspection is the process of gathering information about some objects in
 your program, not by reading the source code, but by querying the object (or a
-controlling object) for some properties, like its type.
+controlling object) for some properties, such as its type.
 
-Given an object C<$p>, and the class definitions from the previous sections,
+Given an object C<$o>, and the class definitions from the previous sections,
 we can ask it a few questions:
 
     if $o ~~ Employee { say "It's an employee" };
@@ -496,7 +496,6 @@ we can ask it a few questions:
 
 The output can look like this:
 
-=for output
     It's an employee
     (Programmer)
     Programmer.new(known_languages => ["Perl", "Python", "Pascal"],
@@ -510,7 +509,7 @@ question is of class C<Employee> or one that inherits from it, but not
 C<GeekCook>.
 
 The C<.WHAT> method returns the type object associated with the object C<$o>,
-which tells the exact type of C<$o>: in this case C<Programmer>.
+which tells us the exact type of C<$o>: in this case C<Programmer>.
 
 C<$o.perl> returns a string that can be executed as Perl code, and reproduces
 the original object C<$o>. While this does not work perfectly in all
@@ -522,11 +521,11 @@ is very useful for debugging simple objects.
 
 C<$o.^methods(:local)> produces a list of methods that can be called
 on C<$o>. The C<:local> named argument limits the returned methods to those
-defined in the C<Employee> class, and excludes the inherited methods.
+defined in the C<Employee> class and excludes the inherited methods.
 
-The syntax of calling method with C<.^> instead of a single dot means that it
-is actually a method call on the I<meta class>, which is  a class managing the
-properties of the C<Employee> class - or any other class you are interested
+The syntax of calling a method with C<.^> instead of a single dot means that it
+is actually a method call on the I<meta class>, which is a class managing the
+properties of the C<Employee> class -- or any other class you are interested
 in. This meta class enables other ways of introspection too:
 
     say $o.^attributes.join(', ');
@@ -537,9 +536,9 @@ unsurprisingly returns the class name.
 
 Introspection is very useful for debugging, and for learning the language
 and new libraries. When a function or method
-returns an object you don't know about, finding its type with C<.WHAT>, a
-construction recipe for it with C<.perl> and so on you'll get a good idea what
-this return value is. With C<.^methods> you can learn what you can do with it.
+returns an object you don't know about, finding its type with C<.WHAT>, seeing a
+construction recipe for it with C<.perl>, and so on, you'll get a good idea of what
+its return value is. With C<.^methods> you can learn what you can do with the class.
 
 But there are other applications too: a routine that serializes objects to a
 bunch of bytes needs to know the attributes of that object, which it can find