# Day 16 – Quoting on Steroids

A few days ago, there was a blog post about String Interpolation. Most of the examples there used a simple double quoted string.
``` my \$a = 42; say "a = \$a"; # a = 42 ```

The possibilities of the double quoted string are quite powerful already. But in the end, they’re just a special case of a much more generic and malleable quoting construct, named Q.

### Q’s Basic Features

In its most generic form, Q just copies the string without any changes or interpretation:
``` my \$a = 42; say Q/foo \$a \n/; # foo \$a \n ```

You can add adverbs to Q[…], to change the way the resulting string will be formatted. For instance, if you want to have interpolation of scalars, you can add :s. If you want interpretation of backslashes like \n, you can add :b. And you can combine them:
``` my \$a = 42; say Q:s/foo \$a\n/;   # foo 42\n say Q:b/foo \$a\n/;   # foo \$a␤ say Q:s:b/foo \$a\n/; # foo 42␤ ```

(If you wonder what a is, it is a U+2424 SYMBOL FOR NEWLINE [So] (␤) and should be show up in your browser as a character containing an N and an L as a visible representation of a new line character)

In fact, the list of adverbs of basic features is:

```    short       long            what does it do
=====       ====            ===============
:q          :single         Interpolate \\, \q and \' (or whatever)
:s          :scalar         Interpolate \$ vars
:a          :array          Interpolate @ vars
:h          :hash           Interpolate % vars
:f          :function       Interpolate & calls
:c          :closure        Interpolate {...} expressions
:b          :backslash      Interpolate \n, \t, etc. (implies :q at least)
```

The :q (:single) basically gives you single quoted string semantics. The other adverbs, give you typically the functionality that you would expect from double quoted strings. If you really want to be verbose on your double quoted strings, you can write them like this:
``` my \$a = 42; say Q :scalar :array :hash :function :closure :backslash /foo \$a\n/; # foo 42␤ ```

Of course, you can also specify the short versions of the adverbs, and not separate them by whitespace. So, if you want to be less verbose:
``` my \$a = 42; say Q:s:a:h:f:c:b/foo \$a\n/; # foo 42␤ ```

As with any adverbs (which are just named parameters, really), the order does not matter:
``` my \$a = 42; say Q:f:s:b:a:c:h/foo \$a\n/; # foo 42␤ ```

Actually, the story about the order of the named parameters is a little bit more complicated than this. But for this set of adverbs, it does not matter in which order they are specified.

.oO( is that a brother of Johann Sebastian? )

But seriously, that is still a mouthful. So an even shorter shortcut is provided: :qq

```    short       long            what does it do
=====       ====            ===============
:qq         :double         Interpolate with :s, :a, :h, :f, :c, :b
```

So, you can:
``` my \$a = 42; say Q:double/foo \$a\n/; # foo 42␤ say Q:qq/foo \$a\n/; # foo 42␤ ```

All that for simply doing a double quoted string with interpolation? Well, because people are using double quoted strings a lot, the simple remains the quickest way of interpolating values into a string. However, underneath that all, it’s really Q:qq, which in turn is really Q:s:a:h:f:c:b.

What about a double quoted string that has double quotes in it? For those cases, the Q:qq form is available, but that is still quite verbose. Synopsis 2 therefore specifies:

```In fact, all quote-like forms derive from Q with adverbs:
q//         Q:q//
qq//        Q:qq//
```

Which means we can shorten the Q:qq in that last example to qq (and have double quotes in the double quoted string without any problems):
``` my \$a = 42; say qq/foo "\$a"\n/; # foo "42"␤ ```

Both q// and qq// also support (the same) adverbs. This initially seems the most useful with q//, for instance in combination with :s, which would (also) interpolate scalars:
``` my \$a = 42; say q:s/foo "\$a"\n/; # foo "42"\n ```

However, adverbs (just as named parameters) are just a shortcut for a Pair: :s is really s => True. And :!s is really just s => False. Can we also apply this to quoting constructs? The answer is: yes, you can!
``` say qq:!s:!c/foo "\$x{\$y}"\n/; # foo "\$x{\$y}"␤ ```

Even though we specified qq//, the scalar is not interpolated, because of the :!s adverb. And the scope is not interpolated, because of the :!c. This can for instance be handy when building strings to be EVALled. So, if you want all quoting features except one or more, you can easily de-activate that feature by negating those adverbs.

### Some of Q’s Advanced Features

Quoting features do not stop here. This is a list of some of the other features that already work in Rakudo Perl 6:

```    short       long            what does it do
=====       ====            ===============
: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)
:to         :heredoc        Parse result as heredoc terminator
```

Here are some examples. Note that we don’t bother specifying these features as attributes, because they’re basically the first additional attribute, so there is a shortcut version for them. For example, qq:x// can be shortened to qqx//. Whether you could consider that more readable or not, I leave up to the reader. There is, after all, more than one way to do it.

Interpolate and execute as an external program:
``` my \$w = 'World'; say qqx/echo Hello \$w/; # Hello World ```

Interpolate as single quoted words (please look at what happens to the single quotes):
``` .say for qw/ foo bar 'first second' /; == foo bar 'first second' ```

Interpolate as single quoted words with quote protection. This will make sure that balanced quotes will be treated as one entity (and note again what happened to the single quotes).
``` .say for qww/ foo bar 'first second' /; == foo bar first second ```

Interpolate variables into a heredoc:
``` my \$a = 'world'; say qqto/FOO/;   Hello \$a   FOO == Hello world␤ ```
The text is exdented automatically for the same number of indents as the target has.

### Conclusion

Perl 6 has a very powerful basic quoting construct in Q[…], from which all other quoting constructs are derived. They allow mix and matching of features in various short and more verbose ways. There are still some adverbs unimplemented, but the ones that are mentioned here, should Just Work™.

Finally, the Synopsis also indicates that there will be a way out of this alphabet soup:

```If you want to abbreviate further, just define a macro:

macro qx { 'qq:x ' }          # equivalent to P5's qx//
macro qTO { 'qq:x:w:to ' }    # qq:x:w:to//
macro quote:<❰ ❱> (\$text) { quasi { {{{\$text}}}.quoteharder } }
```

We can only hope that someone will find enough quality tuits soon to implement this.

## 4 thoughts on “Day 16 – Quoting on Steroids”

1. Wolfram says:

J.S.Bach is Johann, not Johannes

1. liztormato says:

Thank you. Fixed!

2. For newcomers who might be a little overwhelmed by the flexibility of the Q constuct, here’s the list of forms that actually tend to be used in practice in normal Perl 6 code, from what I’ve seen:

——-

`Q[...]` for verbatim strings without any interpolating/escaping.

`'...'` or `q[...]` for strings without variable interpolation or escape sequences, except for escaping the end delimiter and the backslash itself. The second form is useful when the string contains apostrophes and you don’t want to have to escape them all.

`"..."` or `qq[...]` for strings with variable interpolation and escape sequences like `\n`. The second form is useful when the string contains quotation marks and you don’t want to have to escape them all.

`<...>` for a list of words. (I don’t remember seeing the Perl 5-like `qw[...]` form out in the wild in Perl 6 code.)

`<<...>>` or `«...»` for a list of words with quote protection. (I don’t remember seeing the `qww[...]` form out in the wild in Perl 6 code.)

`qx[...]` or `qqx[...]` or `shell("...")` for running a shell command and returning the result.

``````q:to[END];
...
END``````

for heredocs.

`/.../` or `rx[...]` for regexes.

——-

I’ve shown them with square bracket delimiters here, but forward slashes are also commonly used. Unlike in Perl 5, parens are not allowed as delimiters, because when the parser sees something like `q(...)` it thinks it’s a function call.

Explicit adverb forms like `Q:qq[...]` are something that doesn’t seem to be used much in normal code, but I imagine the fact that the Q construct is so generic and modular will come in handy when module authors want to provide their own, domain-specific quoting forms.

1. liztormato says:

Thanks for the elaboration! :-)

Actually, parentheses are allowed, but must be separated by whitespace:

``` say Q (foo); # foo ```