Extensive word substitution and reflow

Author: JJ

doc/Language/5to6-perlfunc.pod6

@@ -6,9 +6,8 @@
 
 =head1 DESCRIPTION
 
-A (hopefully) comprehensive list of Perl 5 builtin functions with their
-Perl 6 equivalents with notes on variations between them where
-necessary.
+A (hopefully) comprehensive list of Perl 5 builtin functions with their Perl 6
+equivalents with notes on variations between them where necessary.
 
 =head1 NOTE
 
@@ -52,8 +51,8 @@ readable using smartmatch:
 
     '/path/to/file'.IO ~~ :r
 
-You can, of course, use an already opened filehandle. Here, using the file
-handle C<$fh>, is an example, using the method syntax for the file test:
+You can, of course, use an already opened filehandle. Here, using the filehandle
+C<$fh>, is an example, using the method syntax for the file test:
 
 =for code :preamble<my $fh;>
 $fh.r

doc/Language/exceptions.pod6

@@ -4,12 +4,11 @@
 
 =SUBTITLE Using exceptions in Perl 6
 
-Exceptions in Perl 6 are objects that hold information about errors.
-An error can be, for example, the unexpected receiving of data or a
-network connection no longer available, or a missing file.
-The information that an exception objects store is, for instance,
-a human-readable message about the error condition, the backtrace
-of the raising of the error, and so on.
+Exceptions in Perl 6 are objects that hold information about errors. An error
+can be, for example, the unexpected receiving of data or a network connection no
+longer available, or a missing file. The information that an exception objects
+store is, for instance, a human-readable message about the error condition, the
+backtrace of the raising of the error, and so on.
 
 All built-in exceptions inherit from L<Exception>, which provides some basic
 behavior, including the storage of a backtrace and an interface for the
@@ -61,9 +60,9 @@ Here, we are saying that if any exception of type C<X::IO> occurs, then the
 message C<some kind of IO exception was caught!> will be sent to I<stderr> and
 displayed.
 
-A X<C<CATCH>|CATCH> block uses smartmatching similar to how C<given/when> smart
-matches on options, thus it's possible to catch and handle various categories of
-exceptions inside a C<when> block.
+A X<C<CATCH>|CATCH> block uses smartmatching similar to how C<given/when>
+smartmatches on options, thus it's possible to catch and handle various
+categories of exceptions inside a C<when> block.
 
 To handle all exceptions, use a C<default> statement. This example prints out
 almost the same information as the normal backtrace printer.

doc/Language/faq.pod6

@@ -11,9 +11,8 @@ X<|Rakudo and Perl 6 (FAQ)>
 
 Properly speaking, L<Rakudo|http://rakudo.org/> is an implementation of Perl 6.
 It's currently the most developed, but there have been other implementations in
-the past and there will likely be others in the future. Perl 6 is the
-definition of the language. Often, Rakudo and Perl 6 will be used
-interchangeably.
+the past and there will likely be others in the future. Perl 6 is the definition
+of the language. Often, Rakudo and Perl 6 will be used interchangeably.
 
 =head2 Has Perl 6 been released?
 
@@ -739,15 +738,22 @@ them offer all.
 
 =item High level concurrency model, both for implicit as well as explicit multi-processing, which goes way beyond primitive threads and locks. Perl 6's concurrency offers a rich set of (composable) tools.
 
-=item Multiple-core computers are getting used more and more, and with Perl 6 these can be used thanks to parallelism, both implicit (e.g., with the >>. method) and explicit ( start { code } ). This is important, because Moore's Law is ending.
+=item Multiple-core computers are getting used more and more, and with Perl 6
+these can be used thanks to parallelism, both implicit (e.g., with the C«>>».
+method) and explicit ( C<start { code }> ). This is important, because Moore's
+Law is ending.
 
 =item Structured language support is provided to enable programming for asynchronous execution of code.
 
-=item Supplies allow code to be executed when something happens (like a timer, or a signal, or a file-system event).
+=item Supplies allow code to be executed when something happens (like a timer,
+or a signal, or a filesystem event).
 
-=item react / whenever / supply keywords allows easy construction of interactive, event driven applications.
+=item react / whenever / supply keywords allows easy construction of
+interactive, event driven applications.
 
-=item Lazy evaluation when possible, eager evaluation when wanted or necessary. This means, for example, lazy lists, and even infinite lazy lists, like the Fibonacci sequence, or all prime numbers.
+=item Lazy evaluation when possible, eager evaluation when wanted or necessary.
+This means, for example, lazy lists, and even infinite lazy lists, like the
+Fibonacci sequence, or all prime numbers.
 
 =item Native data types for faster, closer to the metal, processing.
 

doc/Language/objects.pod6

@@ -8,15 +8,14 @@ Perl 6 provides strong support for L<Object Oriented Programming (OOP)|https://
 Although Perl 6 allows programmers to program in multiple paradigms,
 Object Oriented Programming is at the heart of the language.
 
-Perl 6 comes with a wealth of predefined types, which can be classified in
-two categories: normal and I<native> types.
-Everything that you can store in a variable is either a I<native value> or an
-I<object>. That includes literals, types (type objects), code and containers.
+Perl 6 comes with a wealth of predefined types, which can be classified in two
+categories: normal and L<I<native> types|/language/nativetypes>. Everything that
+you can store in a variable is either a I<native value> or an I<object>. That
+includes literals, types (type objects), code and containers.
 
-
-Native types are used for low-level types (like C<uint64>).
-Even if I<native> types do not have the same capabilities as objects,
-if you call methods on them, they are automatically I<boxed> into normal objects.
+Native types are used for low-level types (like C<uint64>). Even if I<native>
+types do not have the same capabilities as objects, if you call methods on them,
+they are automatically I<boxed> into normal objects.
 
 Everything that is not a I<native> value is an <object>.
 Objects do allow for both L<inheritance|https://en.wikipedia.org/wiki/Object-oriented_programming#Inheritance_and_behavioral_subtyping> and L<encapsulation|https://en.wikipedia.org/wiki/Object-oriented_programming#Encapsulation>.
@@ -63,9 +62,8 @@ unambiguously a method call without an argument list:
     say 4.log: +2; # OUTPUT: «2␤» ( base-2 logarithm of 4 )
     say 4.log  +2; # OUTPUT: «3.38629436111989␤» ( natural logarithm of 4, plus 2 )
 
-Many operations that don't look like method calls (for example, smart
-matching, or interpolating an object into a string) result in method calls
-under the hood.
+Many operations that don't look like method calls (for example, smartmatching or
+interpolating an object into a string) result in method calls under the hood.
 
 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

doc/Language/regexes.pod6

@@ -244,10 +244,10 @@ character.
 
 =head2 X«Unicode Properties|regex,<:property>»
 
-The character classes mentioned so far are mostly for convenience;
-another approach is to use Unicode character properties. These come in
-the form C«<:property>», where C<property> can be a short or long
-Unicode General Category name. These use pair syntax.
+The character classes mentioned so far are mostly for convenience; another
+approach is to use Unicode character properties. These come in the form
+C«<:property>», where C<property> can be a short or long Unicode General
+Category name. These use pair syntax.
 
 To match against a Unicode property you can use either smartmatch or L<C<uniprop>|/routine/uniprop>:
 
@@ -746,7 +746,7 @@ X«C<\b>|regex deprecated,\b» of other languages.
 To match not a word boundary, use C«<!|w>» or C«<!wb>». This is similar to
 X«C<\B>|regex deprecated,\B» of other languages.
 
-These are both zero width regex elements.
+These are both zero-width regex elements.
 
     say "two-words" ~~ / two<|w>\-<|w>words /;    # OUTPUT: «｢two-words｣␤»
     say "twowords" ~~ / two<!|w><!|w>words /;     # OUTPUT: «｢twowords｣»
@@ -763,7 +763,7 @@ C«>>» matches a right word boundary. It matches positions where there
 is a word character at the left and a non-word character at the right, or
 the end of the string.
 
-These are both zero width regex elements.
+These are both zero-width regex elements.
 
     my $str = 'The quick brown fox';
     say so ' ' ~~ /\W/;               # OUTPUT: «True␤»

doc/Language/unicode.pod6

@@ -16,10 +16,11 @@ L<MoarVM string documentation|https://github.com/MoarVM/MoarVM/blob/master/docs/
 X<|Normalization>
 =head2 Normalization
 
-Perl6 applies normalization by default to all input and output except for
-file names which are stored as L<C<UTF8-C8>|#UTF8-C8>; graphemes, which are user-visible forms of the characters, will use a normalized representation.
-What does this mean? For example, the grapheme C<á> can be represented in two ways, either using
-one codepoint:
+Perl 6 applies normalization by default to all input and output except for file
+names which are stored as L<C<UTF8-C8>|#UTF8-C8>; graphemes, which are
+user-visible forms of the characters, will use a normalized representation. What
+does this mean? For example, the grapheme C<á> can be represented in two ways,
+either using one codepoint:
 
 =for code :lang<text>
 á (U+E1 "LATIN SMALL LETTER A WITH ACUTE")
@@ -54,11 +55,12 @@ X<|UTF8-C8>
 =head2 UTF8-C8
 
 X<UTF-8 Clean-8> is an encoder/decoder that primarily works as the UTF-8 one.
-However, upon encountering a byte sequence that will either not decode as
-valid UTF-8, or that would not round-trip due to normalization, it will use
-L<NFG synthetics|/language/glossary#NFG> to keep track of the original bytes involved. This means that
-encoding back to UTF-8 Clean-8 will be able to recreate the bytes as they
-originally existed. The synthetics contain 4 codepoints:
+However, upon encountering a byte sequence that will either not decode as valid
+UTF-8, or that would not round-trip due to normalization, it will use
+L<NFG synthetics|/language/glossary#NFG>
+to keep track of the original bytes involved.
+This means that encoding back to UTF-8 Clean-8 will be able to recreate the
+bytes as they originally existed. The synthetics contain 4 codepoints:
 
 =item The codepoint 0x10FFFD (which is a private use codepoint)
 =item The codepoint 'x'
@@ -69,12 +71,14 @@ Under normal UTF-8 encoding, this means the unrepresentable characters will
 come out as something like C<?xFF>.
 
 UTF-8 Clean-8 is used in places where MoarVM receives strings from the
-environment, command line arguments, and file system queries, for instance when decoding buffers:
+environment, command line arguments, and filesystem queries, for instance when decoding buffers:
 
     say Buf.new(ord('A'), 0xFE, ord('Z')).decode('utf8-c8');
     #  OUTPUT: «A􏿽xFEZ␤»
 
-You can see how the two initial codepoints used by UTF8-C8 show up here, right before the "FE". You can use this type of encoding to read files with unknown encoding:
+You can see how the two initial codepoints used by UTF8-C8 show up here, right
+before the "FE". You can use this type of encoding to read files with unknown
+encoding:
 
     my $test-file = "/tmp/test";
     given open($test-file, :w, :bin) {

doc/Type/IO/Path.pod6

@@ -11,7 +11,7 @@ The workhorse of IO operations.
 
 Conceptually, an C<IO::Path> object consists of a volume, a directory, and a
 basename. It supports both purely textual operations, and operations that access
-the file system, e.g. to resolve a path, or to read all content of a file.
+the filesystem, e.g. to resolve a path, or to read all content of a file.
 
 At creation, each C<IO::Path> object is given information about the current
 working directory the path might be relative to using the C<$.CWD> attribute
@@ -170,7 +170,7 @@ cleaning up any extraneous path parts:
     IO::Path::Win32.new("foo/./././..////bar")
         .cleanup.say; "foo\..\bar".IO;         # OUTPUT: «"foo\..\bar".IO␤»
 
-Note that no file system access is made. See also
+Note that no filesystem access is made. See also
 L«C<resolve>|/routine/resolve».
 
 =head2 method comb
@@ -450,7 +450,7 @@ Defined as:
     multi method parent(IO::Path:D: --> IO::Path:D)
     multi method parent(IO::Path:D: UInt:D $level --> IO::Path:D)
 
-Returns the parent path of the invocant. Note that no file system access
+Returns the parent path of the invocant. Note that no filesystem access
 is made, so the returned parent is physical and not the logical parent of
 symlinked directories.
 

doc/Type/Supply.pod6

@@ -789,7 +789,7 @@ L<RT #132012|https://rt.perl.org/Ticket/Display.html?id=132012>
 method watch-path($path --> Supply:D)
 
 Creates a supply to which the OS will emit values to indicate changes on the
-file system for the given path.  Also has a shortcut with the C<watch> method
+filesystem for the given path.  Also has a shortcut with the C<watch> method
 on an IO object, like this:
 
 =for code