Author: larry
Date: Thu Feb  8 13:04:46 2007
New Revision: 13575


Added mother-of-all-quoting-forms Q// for compositional sanity.
qn// is now gone, since Q// does that without having to "undo" a q//.

Modified: doc/trunk/design/syn/S02.pod
--- doc/trunk/design/syn/S02.pod        (original)
+++ doc/trunk/design/syn/S02.pod        Thu Feb  8 13:04:46 2007
@@ -1917,6 +1917,26 @@
 =item *
+In addition to C<q> and C<qq>, there is now the base form C<Q> which does
+I<no> interpolation unless explicitly modified to do so.  So C<q> is really
+short for C<Q:q> and C<qq> is short for C<Q:qq>.  In fact, all quote-like
+forms derive from C<Q> with adverbs:
+    q//         Q :q //
+    qq//        Q :qq //
+    rx//        Q :regex //
+    s///        Q :subst ///
+    tr///       Q :trans ///
+Adverbs such as C<:regex> change the language to be parsed by switching
+to a different parser.  This can completely change the interpreation
+of any subsequent adverbs as well as the quoted material itself.
+    q:s//       Q :q :scalar //
+    rx:s//      Q :regex :sigspace //
+=item *
 Generalized quotes may now take adverbs:
     Short       Long            Meaning
@@ -1924,8 +1944,6 @@
     :x          :exec           Execute as command and return results
     :w          :words          Split result on words (no quote protection)
     :ww         :quotewords     Split result on words (with quote protection)
-    :t          :to             Interpret result as heredoc terminator
-    :n          :none           No escapes at all (unless otherwise adverbed)
     :q          :single         Interpolate \\, \q and \' (or whatever)
     :qq         :double         Interpolate with :s, :a, :h, :f, :c, :b
     :s          :scalar         Interpolate $ vars
@@ -1934,6 +1952,10 @@
     :f          :function       Interpolate & calls
     :c          :closure        Interpolate {...} expressions
     :b          :backslash      Interpolate \n, \t, etc. (implies :q at least)
+                :to             Parse result as heredoc terminator
+                :regex          Parse as regex
+                :subst          Parse as substitution
+                :trans          Parse as transliteration
                 :code           Quasiquoting
 Ordinarily the colon is required on adverbs, but the C<quote> declarator
@@ -1941,11 +1963,11 @@
 without an intervening colon:
     quote qw;                   # declare a P5-esque qw// meaning q:w
-    quote qn;                   # completely raw quote qn//
-    quote qnc;                  # q:n:c//, interpolate only closures
+    quote Qc;                   # Q:c//, interpolate only closures
-Actually, the first two are already assumed, because you get all of the
-forms that use as single character predeclared for free.
+Actually, those two are already assumed, because you get all of the
+forms that use a single character modifier predeclared for free.  (Note
+this means that C<qx//> doesn't intepolate.)
 If you want to abbreviate further, you may also give an explicit
 definition as either a string or quasiquote:
@@ -1957,28 +1979,28 @@
 In particular, all these forms disable the lookahead for an adverbial argument,
 as if there were a space after the keyword.  So although
-    q:n($foo)
+    q:s($foo)
-will misinterpret C<$foo> as the C<:n> argument,
+will misinterpret C<$foo> as the C<:s> argument,
-    qn(stuff)
+    qs(stuff)
-has the advantage of misinterpreting it as the argument to the C<qn()>
+has the advantage of misinterpreting it as the argument to the C<qs()>
 function instead.  C<:)>
 But parens are special that way.  (Even C<q()> is assumed to be a
 function call rather than a quote.)  Other bracketing characters are
 special only if they can be mistaken for adverbial arguments, so
-    qn[stuff]
+    qs[stuff]
 is fine, and means
-    q:n /stuff/
+    q:s /stuff/
-    q:n[stuff]
+    q:s[stuff]
 also happens to work because quote adverbs only allow the paren form of
 bracketed adverbs.
@@ -1987,16 +2009,16 @@
 adverbs and operators as standard macros.  The main difference is that,
-    quote qn = 'q:n';
+    quote qs = 'q:s';
 declaring something like
-    macro qn { 'q:n' }
+    macro qs { 'q:s' }
 does I<not> disable the subsequent search for a parenthesized argument
 to C<:n>.  To get the equivalent, you need to add a space:
-    macro qn { 'q:n ' }
+    macro qs { 'q:s ' }
 All the uppercase adverbs are reserved for user-defined quotes.
 All Unicode delimiters above Latin-1 are reserved for user-defined quotes.

Reply via email to