Changed some examples to a case that feels a bit more real

And shows intent refs #1748. Also separates code in different
examples, leaving the text as text, so it addresses 4 and 5. It closes

Still it should also show an example where the method chaining does
not work by using some data structure that can be used as the last
argument to something, but does not have that something as a method.

Author: JJ

doc/Language/operators.pod6

@@ -2490,38 +2490,46 @@ case of routines/methods that take a single argument or where the first argument
 is a block, it's often required that you call with parentheses (though this
 is not required for the very last routine/method).
 
-    # Traditional structure, read bottom-to-top
-    my @result =
-        sort                # (4) Sort, result is <Earth People>
-        grep { /<[PE]>/ },  # (3) Look for P or E
-        map { .tc },        # (2) Capitalize the words
-        <people of earth>;  # (1) Start with the input
+This  "traditional" structure, read bottom-to-top, with the last two
+lines creating the data structure that is going to be processed
+
+    my @fractions = <TWO THREE FOUR FIVE SEVEN> »~» " " X~ <FIFTHS SIXTHS EIGHTHS>;
+    my @result = map { .uniparse },                    # (3) Converts to unicode
+        grep { .uniparse },                            # (2) Checks if it parses
+        map( {"VULGAR FRACTION " ~ $^þ }, @fractions); # (1) Adds string to input
+
+    # @result is [⅖ ⅗ ⅜ ⅘ ⅚ ⅝ ⅞]
+    
+Now we use the feed operator (left-to-right) with parentheses, read top-to-bottom
 
-    # Feed (left-to-right) with parentheses, read top-to-bottom
     my @result = (
-        <people of earth>   # (1) Start with the input
-        ==> map({ .tc })    # (2) Capitalize the words
-        ==> grep /<[PE]>/   # (3) Look for P or E
-        ==> sort            # (4) Sort, result is <Earth People>
+        <TWO THREE FOUR FIVE SEVEN> »~» " " X~ <FIFTHS SIXTHS EIGHTHS> # (1) Input
+        ==> map( {"VULGAR FRACTION " ~ $^þ } )                         # (2) Converts to Unicode name
+        ==> grep({ .uniparse })                                        # (3) Filters only real names
+        ==> map( { .uniparse} );                                       # (4) Converts to unicode
     );
 
-    # For illustration, method chaining equivalent, read top-to-bottom
-    my @result =
-        <people of earth>   # (1) Start with the input
-        .map({ .tc })       # (2) Capitalize the words
-        .grep(/<[PE]>/)     # (3) Look for P or E
-        .sort;              # (4) Sort, result is <Earth People>
+For illustration, method chaining equivalent, read top-to-bottom, using the same sequence as above
+
+    my @result = ( <TWO THREE FOUR FIVE SEVEN> »~» " " X~ <FIFTHS SIXTHS EIGHTHS>)
+        .map( {"VULGAR FRACTION " ~ $^þ } )
+        .grep({ .uniparse })
+        .map({ .uniparse });
 
-    # To assign without the need of parentheses use another feed operator
+Although in this particular case the result is the same, the feed operator C«==>» more clearly
+    shows intent with arrow pointing the data flow.  To assign without
+    the need of parentheses use another feed operator
+    
     my @result;
     <people of earth>
         ==> map({ .tc })
         ==> grep /<[PE]>/
         ==> sort()
         ==> @result;
 
-    # It can be useful to capture a partial result, however, unlike
-    # the leftward feed operator, it does require parentheses or a semicolon
+It can be useful to capture a partial result, however, unlike the
+    leftward feed operator, it does require parentheses or a semicolon
+    
     my @result;
     <people of earth>
         ==> map({ .tc })