Add summary to RFC 145 article

20th/articles/rfc145.md

@@ -86,8 +86,7 @@ for us if there had been multiple options for the opening one.
 
 To compute the closing brace, it would suffice to have a way to capture
 the opening brace and pass it to a function whose return value is dynamically
-interpolated into the regex. This is now easy in Raku [regexes] and
-in particular `Grammar`s:
+interpolated into the regex. This is now easy in Raku [regexes] and [grammars]:
 
 ``` raku
 grammar Formula {
@@ -142,11 +141,19 @@ Braces: ( * ) ||| Subexpr: [b - (a + 1)] * 7
 [the tilde]: https://docs.raku.org/language/regexes#index-entry-regex__tilde-_regex__~-Tilde_for_nesting_structures
 [response]: https://raku.org/archive/doc/design/apo/A05.html#RFC%20145:%20Brace-matching%20for%20Perl%20Regular%20Expressions
 [regexes]: https://docs.raku.org/language/regexes
+[grammars]: https://docs.raku.org/language/grammars
 [longest-token matching]: https://docs.raku.org/language/regexes#Quoted_lists_are_LTM_matches
 
-## Encore!
+## Summary
+
+In summary, brace matching is obviously useful in parsing structured data.
+It was proposed by Eric Roode to make this simple in Perl 6 / Raku. Although
+the feature was not implemented in the proposed form, the task has indeed
+become easier to accomplish and the code much easier to read, notably due
+to the new regex syntax and grammar support.
+
+### Encore!
 
-That would be it for the main dish, but here is the dessert.
 If, like me, you are slightly bothered by the static brace table but are fine
 with heuristics, then the Unicode Consortium may be an unexpected ally. The
 Unicode `Bidi_Mirroring_Glyph` property gives hints about bidirectional
@@ -156,15 +163,15 @@ Raku has built-in support for Unicode properties and we can use this one
 to let the Unicode Consortium pick closing braces for us:
 
 ``` raku
-    sub unicode-reverse ($_) {
+    sub unicode-mirror ($_) {
         join '', .comb.reverse.map: {
             .uniprop('Bidi_Mirroring_Glyph')
                 or .self
         }
     }
 
     token closing ($opening) {
-        "{ unicode-reverse($opening) }"
+        "{ unicode-mirror($opening) }"
     }
 
     regex braced {
@@ -174,7 +181,7 @@ to let the Unicode Consortium pick closing braces for us:
     }
 ```
 
-The `&unicode-reverse` heuristic splits the argument into characters,
+The `&unicode-mirror` heuristic splits the argument into characters,
 reverses their order and then either picks its mirroring glyph, if one
 is defined, or leaves the character as-is, then reassembles them into
 a string. This function successfully turns `<{` into `}>`, for example.
@@ -184,8 +191,8 @@ and punctuation as opening braces now and it has been turned into a
 `regex` for full backtracking power when it is too greedy in consuming
 opening braces.
 
-With these tweaks, we can go nuts and have the grammar do the brace
-matching analogue of free association:
+With these tweaks, we can go nuts and have the grammar do free association
+and match everything that "looks like a brace pair":
 
 ``` console
 -- ([b - (a + 1)] * 7) ---------------------------------------------------------