Wrap paragraphs consistently in setbagmix.pod

Author: paultcochrane

lib/Language/setbagmix.pod

@@ -4,10 +4,10 @@
 
 =SUBTITLE Unique collections and weighted lists in Perl 6
 
-Often, one wants to work with lists of values that are unique. While
-calling L<C<.unique>|unique> on the list repeatedly is certainly an option,
-better still is to use a L<B<C<Set>>|Set> or L<B<C<SetHash>>|SetHash>,
-whose elements are guaranteed to be unique.
+Often, one wants to work with lists of values that are unique. While calling
+L<C<.unique>|unique> on the list repeatedly is certainly an option, better
+still is to use a L<B<C<Set>>|Set> or L<B<C<SetHash>>|SetHash>, whose
+elements are guaranteed to be unique.
 
 =begin comment
 =defn  Set or SetHash
@@ -16,9 +16,8 @@ Collection of distinct objects
 
 Other times, one wants to keep track of the number of occurrences of an
 item. One could use a hash E<emdash> or use the built-in L<B<C<Bag>>|Bag> or
-L<B<C<BagHash>>|BagHash> types (for integer numbers) or the
-L<B<C<Mix>>|Mix> or L<B<C<MixHash>>|MixHash> types (for arbitrary
-numbers).
+L<B<C<BagHash>>|BagHash> types (for integer numbers) or the L<B<C<Mix>>|Mix>
+or L<B<C<MixHash>>|MixHash> types (for arbitrary numbers).
 
 =begin comment
 =defn  Bag or BagHash
@@ -35,15 +34,15 @@ TODO: Partial type graph showing only QuantHash, Setty, Baggy, Mixy, Set,
 The six collection classes C<Set>, C<SetHash>, C<Bag>, C<BagHash>, C<Mix>,
 C<MixHash>, all share similar semantics.
 
-For one thing, as far as they are concerned, identical objects refer to the same
-element -- where identity is determined using the L<WHICH> methods (i.e. the same
-way that the L<===> operator checks identity). For value types like C<Str>, this
-means having the same value; for reference types like C<Array>, it means
-referring to the same object instance.
+For one thing, as far as they are concerned, identical objects refer to the
+same element -- where identity is determined using the L<WHICH> methods
+(i.e. the same way that the L<===> operator checks identity). For value
+types like C<Str>, this means having the same value; for reference types
+like C<Array>, it means referring to the same object instance.
 
-Secondly, they provide a Hash-like interface where the actual elements of the
-collection (which can be objects of any type) are the 'keys', and the associated
-weights are the 'values':
+Secondly, they provide a Hash-like interface where the actual elements of
+the collection (which can be objects of any type) are the 'keys', and the
+associated weights are the 'values':
 
 =table
                       value of $a{$b} if $b       value of $a{$b} if $b
@@ -58,23 +57,23 @@ weights are the 'values':
 =comment TODO: Update this after ab5tract's set/bag/mix operator redesign.
 
 There are many infixes devoted to preforming common operations on
-L<C<Set>s|Set>, such as unions and set differences. Other operations
-include boolean checks, like whether an object is an element of a
-C<Set>, or whether one C<Set> is a subset of another C<Set>.
+L<C<Set>s|Set>, such as unions and set differences. Other operations include
+boolean checks, like whether an object is an element of a C<Set>, or whether
+one C<Set> is a subset of another C<Set>.
 
-These infixes can be written using the UTF-8 character that represents
-the function (like L<C<∈>|∈>, or L<C<∪>|∪>), or they can be written with
-an equivalent ASCII version (like L<C<(elem)>|(elem)> or L<C<(|)>|(|)>).
+These infixes can be written using the UTF-8 character that represents the
+function (like L<C<∈>|∈>, or L<C<∪>|∪>), or they can be written with an
+equivalent ASCII version (like L<C<(elem)>|(elem)> or L<C<(|)>|(|)>).
 
 Most of the time, explicitly using C<Set> objects with these infixes is
 unnecessary. All of the infix operators will work on any objects of type
 L<C<Any>|Any> for its arguments (e.g., L<C<List>s|List>,
 L<C<Parcel>s|Parcel>, L<C<Mix>es|Mix>, etc.) and coerce them to C<Set>s
 where needed.
 
-In some cases, if the type of an argument is a L<Bag>, the
-infix operator will behave in a different but analogous way to the way
-it would behave with only C<Set> arguments.
+In some cases, if the type of an argument is a L<Bag>, the infix operator
+will behave in a different but analogous way to the way it would behave with
+only C<Set> arguments.
 
 =head2 Operators that return C<Bool>
 
@@ -95,8 +94,8 @@ Equivalent to L«(elem)».
 
     only sub infix:<<"\x2209">>($a, $b --> Bool)
 
-Equivalent to C<!(elem)>, i.e., returns C<True> if C<$a> is not an
-element of C<$b>.
+Equivalent to C<!(elem)>, i.e., returns C<True> if C<$a> is not an element
+of C<$b>.
 
 =head3 infix (cont)
 
@@ -115,16 +114,16 @@ Equivalent to L«(cont)».
 
     only sub infix:<<"\x220C">>($a, $b --> Bool)
 
-Equivalent to C<!(cont)>, i.e., returns C<True> if C<$a> does
-not contain C<$b>.
+Equivalent to C<!(cont)>, i.e., returns C<True> if C<$a> does not contain
+C<$b>.
 
 =head3 infix (<=)
 
     multi sub infix:<<(<=)>>(Any $a, Any $b --> Bool)
     multi sub infix:<<(<=)>>(Setty $a, Setty $b --> Bool)
 
-Returns C<True> if C<$a> is a B<subset> or is equal to C<$b>, i.e., if all the
-elements of C<$a> are elements of C<$b> and C<$a> is a smaller or equal
+Returns C<True> if C<$a> is a B<subset> or is equal to C<$b>, i.e., if all
+the elements of C<$a> are elements of C<$b> and C<$a> is a smaller or equal
 sized set than C<$b>.
 
 =head4 infix ⊆
@@ -165,8 +164,8 @@ Equivalent to C«!(<)».
     multi sub infix:<<(>=)>>(Any $a, Any $b --> Bool)
     multi sub infix:<<(>=)>>(Setty $a, Setty $b --> Bool)
 
-Like L«(<=)» with reversed arguments. Returns C<True> if C<$a>
-is a B<superset> of or equal to C<$b>.
+Like L«(<=)» with reversed arguments. Returns C<True> if C<$a> is a
+B<superset> of or equal to C<$b>.
 
 =head4 infix ⊇
 
@@ -185,8 +184,8 @@ Equivalent to C«!(>=)».
     multi sub infix:<<(>)>>(Any $a, Any $b --> Bool)
     multi sub infix:<<(>)>>(Setty $a, Setty $b --> Bool)
 
-Like L«(<)» with reversed arguments. Returns C<True> if C<$a>
-is a B<strict superset> of C<$b>.
+Like L«(<)» with reversed arguments. Returns C<True> if C<$a> is a
+B<strict superset> of C<$b>.
 
 =head4 infix ⊃
 
@@ -221,8 +220,8 @@ Equivalent to L«(<+)».
     multi sub infix:<<(>+)>>(Any $a, Any $b --> Bool)
 
 Returns C<True> if C<$a> is a Baggy B<superset> of C<$b>, i.e., if all the
-elements of C<$b> are in C<$a> and no argument of C<$a> is weighted
-heavier than that element is in C<$b>.
+elements of C<$b> are in C<$a> and no argument of C<$a> is weighted heavier
+than that element is in C<$b>.
 
 =head4 infix ≽
 
@@ -241,9 +240,9 @@ C<Set> that contains all the elements its arguments contain.
 
     <a a b c d> (|) <h g f e d c> (|) <i j> === set <a b c d e f g h i j>
 
-If any of its arguments are C<Baggy>, it creates a new C<Bag> that
-contains all the elements of the arguments, each weighed by the highest
-weight that appeared for that element.
+If any of its arguments are C<Baggy>, it creates a new C<Bag> that contains
+all the elements of the arguments, each weighed by the highest weight that
+appeared for that element.
 
     bag(<a a b c a>) (|) bag(<a a b c c>) === bag(<a a a b c c>)
 
@@ -257,16 +256,16 @@ Equivalent to L«(V<|>)».
 
     only sub infix:<(&)>(**@p)
 
-Returns the B<intersection> of all of its arguments. Generally, this
-creates a new C<Set> that contains only the elements that all of its
-arguments contain.
+Returns the B<intersection> of all of its arguments. Generally, this creates
+a new C<Set> that contains only the elements that all of its arguments
+contain.
 
     <a b c> (&) <b c d> === set <b c>
     <a b c d> (&) <b c d e> (&) <c d e f> === set <c d>
 
 If any of its arguments are C<Baggy>, this creates a new C<Bag> that
-contains only the elements that all of the arguments contain, each
-weighted by the maximum weight all of the arguments share for that element.
+contains only the elements that all of the arguments contain, each weighted
+by the maximum weight all of the arguments share for that element.
 
     bag(<a a b c a>) (&) bag(<a a b c c>) === bag(<a a b c>)
 
@@ -280,14 +279,14 @@ Equivalent to L«(&)».
 
     only sub infix:<(-)>(**@p)
 
-Returns the B<set difference> of all its arguments. Generally, this
-returns the C<Set> made up of all the elements the first argument has but
-the rest don't, i.e., of all the elements of the first argument, minus
-the elements from the other arguments.
+Returns the B<set difference> of all its arguments. Generally, this returns
+the C<Set> made up of all the elements the first argument has but the rest
+don't, i.e., of all the elements of the first argument, minus the elements
+from the other arguments.
 
 If the first argument is C<Baggy>, this returns a C<Bag> that contains each
-element of the first argument with its weight subtracted by the weight
-of that element in each of the other arguments.
+element of the first argument with its weight subtracted by the weight of
+that element in each of the other arguments.
 
     bag(<a a b c a d>) (-) bag(<a a b c c>) = bag(<a d>)
     bag(<a a a a c d d d>) (-) bag(<a b d a>) (-) bag(<d c>) = bag(<a a d d>)
@@ -303,10 +302,10 @@ Equivalent to L«(-)».
     multi sub infix:<(^)>(Any $a, Any $b --> Setty)
     multi sub infix:<(^)>(Set $a, Set $b --> Setty)
 
-Returns the B<symmetric set difference> of all its arguments, i.e., a
-C<Set> made up of all the elements that C<$a> has but C<$b> doesn't and
-all the elements C<$b> has but C<$a> doesn't. Equivalent to C<($a ∖ $b)
-∪ ($b ∖ $a)>.
+Returns the B<symmetric set difference> of all its arguments, i.e., a C<Set>
+made up of all the elements that C<$a> has but C<$b> doesn't and all the
+elements C<$b> has but C<$a> doesn't. Equivalent to C<($a ∖ $b) ∪ ($b ∖
+$a)>.
 
 =head4 infix ⊖
 
@@ -335,9 +334,9 @@ Equivalent to L«(.)».
 
     only sub infix:<(+)>(**@p)
 
-Returns the Baggy B<addition> of its arguments, i.e., a C<Bag> that
-contains each element of the arguments with the weights of the element
-across the arguments added together to get the new weight.
+Returns the Baggy B<addition> of its arguments, i.e., a C<Bag> that contains
+each element of the arguments with the weights of the element across the
+arguments added together to get the new weight.
 
     bag(<a a b c a d>) (.) bag(<a a b c c>) === bag(<a a a a a b b c c c d>)