You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
174 lines
135 KiB
HTML
174 lines
135 KiB
HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"/><title>Pollen ◊ commands</title><link rel="stylesheet" type="text/css" href="scribble.css" title="default"/><link rel="stylesheet" type="text/css" href="racket.css" title="default"/><link rel="stylesheet" type="text/css" href="manual-style.css" title="default"/><link rel="stylesheet" type="text/css" href="manual-racket.css" title="default"/><script type="text/javascript" src="scribble-common.js"></script><!--[if IE 6]><style type="text/css">.SIEHidden { overflow: hidden; }</style><![endif]--></head><body id="scribble-racket-lang-org"><div class="tocset"><div class="tocview"><div class="tocviewlist tocviewlisttopspace"><div class="tocviewtitle"><table cellspacing="0" cellpadding="0"><tr><td style="width: 1em;"><a href="javascript:void(0);" title="Expand/Collapse" class="tocviewtoggle" onclick="TocviewToggle(this,"tocview_0");">►</a></td><td></td><td><a href="file:///Users/MB/git/pollen/scribblings/reader.html" class="tocviewselflink" data-pltdoc="x">Pollen ◊ commands</a></td></tr></table></div><div class="tocviewsublistonly" style="display: none;" id="tocview_0"><table cellspacing="0" cellpadding="0"><tr><td align="right">1 </td><td><a href="file:///Users/MB/git/pollen/scribblings/reader.html#%28part._.The_golden_rule%29" class="tocviewlink" data-pltdoc="x">The golden rule</a></td></tr><tr><td align="right">2 </td><td><a href="file:///Users/MB/git/pollen/scribblings/reader.html#%28part._.About_that_lozenge%29" class="tocviewlink" data-pltdoc="x">About that lozenge</a></td></tr><tr><td align="right">3 </td><td><a href="file:///Users/MB/git/pollen/scribblings/reader.html#%28part._.The_two_command_forms__native_form___.Racket_form%29" class="tocviewlink" data-pltdoc="x">The two command forms:<span class="mywbr"> </span> native form & Racket form</a></td></tr><tr><td align="right">4 </td><td><a href="file:///Users/MB/git/pollen/scribblings/reader.html#%28part._.The_.Datum_.Part%29" class="tocviewlink" data-pltdoc="x">The Datum Part</a></td></tr><tr><td align="right">5 </td><td><a href="file:///Users/MB/git/pollen/scribblings/reader.html#%28part._.The_.Body_.Part%29" class="tocviewlink" data-pltdoc="x">The Body Part</a></td></tr></table></div></div></div><div class="tocsub"><table class="tocsublist" cellspacing="0"><tr><td><span class="tocsublinknumber"></span><a href="#%28part._reader%29" class="tocsubseclink" data-pltdoc="x">Pollen ◊ commands</a></td></tr><tr><td><span class="tocsublinknumber">1<tt> </tt></span><a href="#%28part._.The_golden_rule%29" class="tocsubseclink" data-pltdoc="x">The golden rule</a></td></tr><tr><td><span class="tocsublinknumber">2<tt> </tt></span><a href="#%28part._.About_that_lozenge%29" class="tocsubseclink" data-pltdoc="x">About that lozenge</a></td></tr><tr><td><span class="tocsublinknumber">3<tt> </tt></span><a href="#%28part._.The_two_command_forms__native_form___.Racket_form%29" class="tocsubseclink" data-pltdoc="x">The two command forms:<span class="mywbr"> </span> native form & Racket form</a></td></tr><tr><td><span class="tocsublinknumber">3.1<tt> </tt></span><a href="#%28part._.The_command_name%29" class="tocsubseclink" data-pltdoc="x">The command name</a></td></tr><tr><td><span class="tocsublinknumber">3.1.1<tt> </tt></span><a href="#%28part._.Invoking_tag_functions%29" class="tocsubseclink" data-pltdoc="x">Invoking tag functions</a></td></tr><tr><td><span class="tocsublinknumber">3.1.2<tt> </tt></span><a href="#%28part._.Invoking_other_functions%29" class="tocsubseclink" data-pltdoc="x">Invoking other functions</a></td></tr><tr><td><span class="tocsublinknumber">3.1.3<tt> </tt></span><a href="#%28part._.Inserting_the_value_of_a_variable%29" class="tocsubseclink" data-pltdoc="x">Inserting the value of a variable</a></td></tr><tr><td><span class="tocsublinknumber">3.1.4<tt> </tt></span><a href="#%28part._lalala%29" class="tocsubseclink" data-pltdoc="x">lalala</a></td></tr><tr><td><span class="tocsublinknumber">4<tt> </tt></span><a href="#%28part._.The_.Datum_.Part%29" class="tocsubseclink" data-pltdoc="x">The Datum Part</a></td></tr><tr><td><span class="tocsublinknumber">5<tt> </tt></span><a href="#%28part._.The_.Body_.Part%29" class="tocsubseclink" data-pltdoc="x">The Body Part</a></td></tr><tr><td><span class="tocsublinknumber">5.1<tt> </tt></span><a href="#%28part._alt-body-syntax%29" class="tocsubseclink" data-pltdoc="x">Alternative Body Syntax</a></td></tr><tr><td><span class="tocsublinknumber">5.2<tt> </tt></span><a href="#%28part._.Racket_.Expression_.Escapes%29" class="tocsubseclink" data-pltdoc="x">Racket Expression Escapes</a></td></tr><tr><td><span class="tocsublinknumber">5.3<tt> </tt></span><a href="#%28part._.Comments%29" class="tocsubseclink" data-pltdoc="x">Comments</a></td></tr><tr><td><span class="tocsublinknumber">5.4<tt> </tt></span><a href="#%28part._.Spaces__.Newlines__and_.Indentation%29" class="tocsubseclink" data-pltdoc="x">Spaces, Newlines, and Indentation</a></td></tr></table></div></div><div class="maincolumn"><div class="main"><div class="versionbox"><span class="versionNoNav">6.0.0.5</span></div><h2><a name="(part._reader)"></a>Pollen ◊ commands</h2><p><span style="font-style: italic">Pollen is a dialect of Scribble, so I’ve adapted this section from Matthew Flatt and Eli Barzilay’s excellent documentation for Scribble. If you think this section is good, it’s because of them. If you don’t, it’s because of me.</span></p><h3>1<tt> </tt><a name="(part._.The_golden_rule)"></a>The golden rule</h3><p>Pollen uses a special character — the <span style="font-style: italic">lozenge</span>, which looks like this: ◊ — to mark commands within a Pollen source file. So when you put a ◊ in your source, whatever comes next will be treated as a command. If you don’t, it will just be interpreted as plain text.</p><h3>2<tt> </tt><a name="(part._.About_that_lozenge)"></a>About that lozenge</h3><p>I chose the lozenge as the command marker because a) it appears in almost every font, b) it’s barely used in ordinary typesetting, c) it’s not used in any programming language that I know of, and d) its shape and color allow it to stand out easily in code without being distracting.</p><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>Scribble itself uses the @ sign as a delimiter. It’s not a bad choice if you only work with Racket files. But as you use Pollen to work on other kinds of text-based files that commonly contain @ signs — HTML pages especially — it gets cumbersome. So I changed it.</p></blockquote></blockquote></blockquote><p>Still, if you don’t want to use the lozenge as your command marker, you can use something else. Set Pollen’s <span class="RktSym"><span class="badlink"><span class="RktValLink">world:command-marker</span></span></span> value to whatever character you want.</p><p>But don’t knock the lozenge till you try it. Here’s how you type it:</p><p>[todo: instructions]</p><h3>3<tt> </tt><a name="(part._.The_two_command_forms__native_form___.Racket_form)"></a>The two command forms: native form & Racket form</h3><p>Every Pollen command is built using one of two basic forms: either <span style="font-style: italic">native form</span> or <span style="font-style: italic">Racket form</span>. Both forms start with a lozenge (<span class="RktInBG"><span class="hspace"></span><span class="RktIn">◊</span><span class="hspace"></span></span>):</p><blockquote class="SCodeFlow"><table cellspacing="0" class="RktBlk"><tr><td><span class="RktInBG"><span class="hspace"></span><span class="RktIn">◊</span><span class="hspace"></span></span><span class="hspace"> </span><span class="sroman">‹<span style="font-style: italic">command name</span>›</span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">[</span><span class="hspace"></span></span><span class="hspace"> </span><span class="sroman">‹<span style="font-style: italic">Racket arguments ...</span>›</span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">]</span><span class="hspace"></span></span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span><span class="hspace"> </span><span class="sroman">‹<span style="font-style: italic">text argument</span>›</span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></td></tr><tr><td><span class="RktInBG"><span class="hspace"></span><span class="RktIn">◊</span><span class="hspace"></span></span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">(</span><span class="hspace"></span></span><span class="hspace"> </span><span class="sroman">‹<span style="font-style: italic">Racket expression</span>›</span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">)</span><span class="hspace"></span></span></td></tr></table></blockquote><p><span style="font-weight: bold">Native-form commands</span></p><p>A native-form command has the three possible parts after the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">◊</span><span class="hspace"></span></span>:</p><ul><li><p>The <span style="font-style: italic">command name</span> appears immediately after the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">◊</span><span class="hspace"></span></span>. Typically it’s a short word.</p></li><li><p>The <span style="font-style: italic">Racket arguments</span> appear between square brackets. Pollen is an interface to the Racket programming language. These arguments are interpreted according to Racket conventions. So if you like programming, you’ll end up using these frequently. If you don’t, you won’t.</p></li><li><p>The <span style="font-style: italic">text argument</span> appears between braces (aka curly brackets). You can put any text here.</p></li></ul><p>Each of the three parts is optional. You can also nest commands within each other. But:</p><ul><li><p>You can never have spaces between the three parts.</p></li><li><p>Whatever parts you use must always appear in the order above.</p></li></ul><p>Here are a few examples of correct native-form commands:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang pollen</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊variable-name</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊tag{Text inside the tag.}</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊tag['attr: "value"]{Text inside the tag}</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊get-customer-id["Brennan Huff"]</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊tag{His ID is ◊get-customer-id["Brennan Huff"].}</span></p></td></tr></table></p><p>And here are some incorrect ones:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang pollen</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊tag {Text inside the tag.} ; space between first and second parts</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊tag[Text inside the tag] ; text argument needs to be within braces</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊tag{Text inside the tag}['attr: "value"] ; wrong order</span></p></td></tr></table></p><p>The next section describes each of these parts in detail.</p><p><span style="font-weight: bold">Racket-form commands</span></p><p>If you’re familiar with Racket expressions, you can use the Racket-form commands to embed them within Pollen source files. It’s simple: any Racket expression can become a Pollen expression by adding <span class="RktInBG"><span class="hspace"></span><span class="RktIn">◊</span><span class="hspace"></span></span> to the front. So in Racket, this code:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang racket</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">(define song "Revolution")</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">(format "~a #~a" song (* 3 3))</span></p></td></tr></table></p><p>Can be converted to Pollen like so:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang pollen</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊(define song "Revolution")</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊(format "~a #~a" song (* 3 3))</span></p></td></tr></table></p><p>And in DrRacket, they produce the same output:</p><blockquote><p><span class="RktRes">"Revolution #9"</span></p></blockquote><p>Beyond that, there’s not much to say about Racket form — any valid expression you can write in Racket will also be a valid Racket-form Pollen command.</p><p><span style="font-weight: bold">The relationship of native form and Racket form</span></p><p>Even if you don’t plan to write a lot of Racket-form commands, you should be aware that under the hood, Pollen is converting all commands in native form to Racket form. So a native-form command that looks like this:</p><blockquote class="SCodeFlow"><p><span class="RktSym">◊headline</span><span class="RktPn">[</span><span class="RktPn">#:size</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">enormous</span><span class="RktPn">]</span><span class="RktPn">{</span><span class="RktSym">Man</span><span class="hspace"> </span><span class="RktSym">Bites</span><span class="hspace"> </span><span class="RktSym">Dog!</span><span class="RktPn">}</span></p></blockquote><p>Is actually being turned into a Racket-form command like this:</p><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym">headline</span><span class="hspace"> </span><span class="RktPn">#:size</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">enormous</span><span class="hspace"> </span><span class="RktVal">"Man Bites Dog!"</span><span class="RktPn">)</span></p></blockquote><p>Thus a native-form command is just an alternate way of writing a Racket-form command. (More broadly, all of Pollen is just an alternate way of using Racket.)</p><p>The corollary is that you can always write Pollen commands using whichever form is more convenient or readable. For instance, the earlier example, written in the Racket form:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang pollen</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊(define song "Revolution")</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊(format "~a #~a" song (* 3 3))</span></p></td></tr></table></p><p>Can be rewritten using native form:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang pollen</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊define[song]{Revolution}</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">◊format["~a #~a" song (* 3 3)]</span></p></td></tr></table></p><p>And it will work the same way.</p><h4>3.1<tt> </tt><a name="(part._.The_command_name)"></a>The command name</h4><p>In Pollen, you’ll typically use the command name for one of four purposes:</p><ul><li><p>To invoke a tag function.</p></li><li><p>To invoke another function.</p></li><li><p>To insert the value of a variable.</p></li><li><p>To insert a comment.</p></li></ul><h5>3.1.1<tt> </tt><a name="(part._.Invoking_tag_functions)"></a>Invoking tag functions</h5><p>By default, Pollen treats every command name as a <span style="font-style: italic">tag function</span>. As the name implies, a tag function creates a tagged X-expression with the command name as the tag, and the text argument as the content.</p><p>Example:
|
|
◊strong{Fancy Sauce, $1} becomes ’(strong "Fancy Sauce, $1")</p><p>To make markup easy, Pollen doesn’t restrict you to a certain set of tags, or make you define your tag functions ahead of time. Just type it, and you can start using it as a tag.</p><p>Example:
|
|
◊utterlyridiculoustagname{Oh really?} becomes ’(utterlyridiculoustagname "Oh really?")</p><p>The one restriction is that you can’t invent names for tag functions that are already being used for other commands. For instance, <span class="RktSym"><span class="badlink"><span class="RktValLink">map</span></span></span> is a command permanently reserved by Racket. It’s also a rarely-used HTML tag. But gosh, you really want to use it. Problem is, if you invoke it directly, Pollen will think you mean the other <span class="RktSym"><span class="badlink"><span class="RktValLink">map</span></span></span>:</p><p>Example:
|
|
◊map{Fancy Sauce, $1} becomes ’(map "Fancy Sauce, $1") ; error</p><p>What to do? Read on.</p><h5>3.1.2<tt> </tt><a name="(part._.Invoking_other_functions)"></a>Invoking other functions</h5><p>Though every command name starts out as a tag function, it doesn’t necessarily end there. You have two options for invoking other functions.</p><p>First, you can use the <span class="RktSym"><span class="badlink"><span class="RktValLink">define</span></span></span> command to create your own function for a command name. After that, when you use the command name, you’ll get the new behavior.</p><p>Example:
|
|
◊strong{Fancy Sauce, $1} becomes ’(strong "Fancy Sauce, $1")
|
|
◊(define (strong . elements) etc....)
|
|
◊strong{Fancy Sauce, $1} becomes new thing</p><p>You can attach any behavior to a command name. As your project evolves, you can also redefine the behavior of a command name. In that way, Pollen markup becomes a set of hooks upon which you can attach more elaborate processing.</p><p>Second, you aren’t limited to your own commands. Any function from Racket or any of its libraries can be invoked directly by using it as a command name:</p><p>[example]</p><p>Combining these two ideas, you can also invoke Racket functions indirectly, by attaching them to your custom command names:</p><p>[example]</p><p>As mentioned above, some command names already have behavior associated with them. But you can use a custom function to work around this. For instance, suppose we want to use <span class="RktSym"><span class="badlink"><span class="RktValLink">map</span></span></span><span class="RktMeta"></span> as a tag even though Racket is using it for its own function called <span class="RktSym"><span class="badlink"><span class="RktValLink">map</span></span></span>.</p><p>First, we invent a command name that doesn’t conflict. Let’s call it <span class="RktSym">my-map</span><span class="RktMeta"></span>. As you learned above, Pollen will treat a new command name as a tag function by default:</p><p>Example:
|
|
◊my-map{How I would love this to be a map.}</p><p>But <span class="RktSym">my-map</span><span class="RktMeta"></span> is not the tag we want. So instead, we attach a function to <span class="RktSym">my-map</span><span class="RktMeta"></span> that creates the tag we want:</p><p>Example:</p><p>◊(define (my-map . elements) ‘(map ,elements))
|
|
◊my-map{How I would love this to be a map.}</p><p>And now we can use <span class="RktSym"><span class="badlink"><span class="RktValLink">map</span></span></span><span class="RktMeta"></span> as a tag by invoking <span class="RktSym">my-map</span><span class="RktMeta"></span>.</p><h5>3.1.3<tt> </tt><a name="(part._.Inserting_the_value_of_a_variable)"></a>Inserting the value of a variable</h5><p>A Pollen command name usually refers to a function, but it can also refer to a <span style="font-style: italic">variable</span>, which is a simple data value. Once you define the variable, you can insert it into your source by using the ◊ notation without any other arguments:</p><p>[Example
|
|
◊(define foo "bar")
|
|
◊p{The value of foo is ◊foo}</p><p>Be careful — if you include arguments, even blank ones, Pollen will treat the command name as a function. This won’t work, because a variable is not a function:</p><p>[Example
|
|
◊(define foo "bar")
|
|
◊p{The value of foo is ◊foo[]}</p><p>The reason we can simply drop ◊foo into the text argument of another Pollen command is that <span class="RktSym">foo</span><span class="RktMeta"></span> holds a text value (i.e., a string). Keep in mind that not every variable holds a string value, and if it doesn’t, you’ll have to convert it to a string if you want to use it within other text.</p><p>[Example
|
|
◊(define zam 42)
|
|
◊p{The value of zam is ◊zam} ;; error
|
|
◊p{The value of zam is ◊number->string[◊zam]} ; works</p><p>One exception to know about. In the examples above, there’s a word space between the variable and the other text. But suppose you need to insert a variable into text so that there’s no space in between. The simple ◊ notation above won’t work, because it won’t be clear where the variable name ends and the text begins.</p><p>For instance, this example fails because Pollen looks for a variable called <span class="RktSym">fooic</span><span class="RktMeta"></span> (which doesn’t exist) rather than <span class="RktSym">foo</span><span class="RktMeta"></span> (which does):</p><blockquote class="SCodeFlow"><table cellspacing="0" class="RktBlk"><tr><td><span class="RktSym">◊</span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">define</span></span></span><span class="hspace"> </span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">Hyper◊fooic</span><span class="hspace"> </span><span class="RktSym">chamber</span></td></tr><tr><td><span class="RktSym"><span class="badlink"><span class="RktValLink">></span></span></span><span class="hspace"> </span><span class="RktSym">ERROR</span></td></tr></table></blockquote><p>In this situation, you can surround the variable name with vertical bars to explicitly indicate where the name ends. The bars are not treated as part of the name, nor are they included in the result.</p><blockquote class="SCodeFlow"><table cellspacing="0" class="RktBlk"><tr><td><span class="RktSym">◊</span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">define</span></span></span><span class="hspace"> </span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">Hyper◊fooic</span><span class="hspace"> </span><span class="RktSym">chamber</span></td></tr><tr><td><span class="RktSym"><span class="badlink"><span class="RktValLink">></span></span></span><span class="hspace"> </span><span class="RktSym">Hyperbaric</span><span class="hspace"> </span><span class="RktSym">chamber</span></td></tr></table></blockquote><h5>3.1.4<tt> </tt><a name="(part._lalala)"></a>lalala</h5><p>Besides being a Racket identifier, the <span class="sroman">‹<span style="font-style: italic">cmd</span>›</span> part of an
|
|
<font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font> can have Racket punctuation prefixes, which will end up
|
|
wrapping the <span style="font-style: italic">whole</span> expression.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@`',@foo{blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktVal">`</span><span class="RktVal">'</span><span class="RktVal">,@</span><span class="RktVal">(</span><span class="RktVal">foo</span><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktVal">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@#`#'#,@foo{blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktRdr">#`</span><span class="RktRdr">#'</span><span class="RktRdr">#,@</span><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr></table></p><p>When writing Racket code, this means that <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@`',@foo{blah}</span><span class="hspace"></span></span>
|
|
is exactly the same as <span class="RktInBG"><span class="hspace"></span><span class="RktIn">`@',@foo{blah}</span><span class="hspace"></span></span> and
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">`',@@foo{blah}</span><span class="hspace"></span></span>, but unlike the latter two, the first
|
|
construct can appear in body texts with the same meaning, whereas the
|
|
other two would not work (see below).</p><p>After the optional punctuation prefix, the <span class="sroman">‹<span style="font-style: italic">cmd</span>›</span> itself is not
|
|
limited to identifiers; it can be <span style="font-style: italic">any</span> Racket expression.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@(lambda (x) x){blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktPn">(</span><span class="RktSym">lambda</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@`(unquote foo){blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktVal">`</span><span class="RktVal">(</span><span class="RktRdr">,</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktVal">)</span></td></tr></table></p><p>In addition, the command can be omitted altogether, which will omit it
|
|
from the translation, resulting in an S-expression that usually
|
|
contains, say, just strings:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{foo bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktVal">"foo bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@'{foo bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">"foo bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="RktVal">)</span></td></tr></table></td></tr></table></p><p>If the command part begins with a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">;</span><span class="hspace"></span></span> (with no newline between
|
|
the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> and the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">;</span><span class="hspace"></span></span>), then the construct is a
|
|
comment. There are two comment forms, one for arbitrary-text and
|
|
possibly nested comments, and another one for line comments:</p><blockquote class="SCodeFlow"><table cellspacing="0" class="RktBlk"><tr><td><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@;{</span><span class="hspace"></span></span><span class="hspace"> </span><span class="sroman">‹<span style="font-style: italic">any</span>›</span><span class="sroman">*</span><span class="hspace"> </span><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></td></tr><tr><td><span class="hspace"> </span></td></tr><tr><td><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@;</span><span class="hspace"></span></span><span class="hspace"> </span><span class="sroman">‹<span style="font-style: italic">anything-else-without-newline</span>›</span><span class="sroman">*</span></td></tr></table></blockquote><p>In the first form, the commented body must still parse correctly; see
|
|
the description of the body syntax below. In the second form, all
|
|
text from the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@;</span><span class="hspace"></span></span> to the end of the line <span style="font-style: italic">and</span> all
|
|
following spaces (or tabs) are part of the comment (similar to
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">%</span><span class="hspace"></span></span> comments in TeX).</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar @; comment</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz@;</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">blah}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar bazblah"</span><span class="RktPn">)</span></td></tr></table></p><p>Tip: if you use an editor in some Scheme mode without support for
|
|
<font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font>, balanced comments can be confusing, since the open brace
|
|
looks commented out, and the closing one isn’t. In such cases it is
|
|
useful to “comment” out the closing brace too:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">@;{</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt"></span><span class="hspace"> </span><span class="stt">...</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">;}</span></p></td></tr></table></p><p>so the editor does not treat the file as having unbalanced
|
|
parentheses.</p><p>If only the <span class="sroman">‹<span style="font-style: italic">cmd</span>›</span> part of an <font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font> is specified, then the
|
|
result is the command part only, without an extra set of parenthesis.
|
|
This makes it suitable for Racket escapes in body texts. (More on this
|
|
below, in the description of the body part.)</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x @y z}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"x "</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktVal">" z"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x @(* y 2) z}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"x "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">*</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" z"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{@foo bar}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar"</span><span class="RktPn">)</span></td></tr></table></p><p>Finally, note that there are currently no special rules for using
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> in the command itself, which can lead to things like:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@@foo{bar}{baz}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="RktPn">)</span></td></tr></table></p><p>Here is one example:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{blah blah blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"blah blah blah"</span><span class="RktPn">)</span></td></tr></table></p><p>The example shows how an input syntax is read as Racket syntax, not
|
|
what it evaluates to. If you want to see the translation of an example
|
|
into S-expression form, add a quote in front of it in a
|
|
<font class="badlink"><span class="RktModLink"><span class="RktMod">#lang</span></span></font><span class="stt"> </span><font class="badlink"><span class="RktModLink"><span class="RktSym">at-exp</span></span></font><span class="stt"> </span><span class="RktSym">racket</span> module. For example, running</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang at-exp racket</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">'@foo{blah blah blah}</span></p></td></tr></table></p><p>in DrRacket prints the output</p><blockquote><p><span class="RktRes">(foo<span class="stt"> </span>"blah blah blah")</span></p></blockquote><p>while omitting the quote</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang at-exp racket</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">@foo{blah blah blah}</span></p></td></tr></table></p><p>triggers a syntax error because <span class="RktSym">foo</span> is not bound, and</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span><span class="stt">#lang at-exp racket</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">(define (foo str) (printf "He wrote ~s.\n" str))</span></p></td></tr><tr><td><p><span class="hspace"> </span><span class="stt">@foo{blah blah blah}</span></p></td></tr></table></p><p>prints the output</p><blockquote><p><span class="RktOut">He wrote "blah blah blah".</span></p></blockquote><p>Here are more examples of <font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font>:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{blah "blah" (`blah'?)}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"blah \"blah\" (`blah'?)"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[1 2]{3 4}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">"3 4"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[1 2 3 4]</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">4</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[#:width 2]{blah blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktPn">#:width</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">"blah blah"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{blah blah</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">yada yada}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"blah blah"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"yada yada"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">blah blah</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">yada yada</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"blah blah"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"yada yada"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>As seen in the last example, multiple lines and the newlines that
|
|
separate them are parsed to multiple Racket strings. More generally,
|
|
a <span class="sroman">‹<span style="font-style: italic">text-body</span>›</span> is made of text, newlines, and nested
|
|
<font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font>, where the syntax for <font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font> is the same whether it’s
|
|
in a <span class="sroman">‹<span style="font-style: italic">text-body</span>›</span> context as in a Racket context. A
|
|
<span class="sroman">‹<span style="font-style: italic">text-body</span>›</span> that isn’t an <font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font> is converted to a string
|
|
expression for its <span class="sroman">‹<span style="font-style: italic">parsed-body</span>›</span>; newlines and following
|
|
indentations are converted to <span class="RktVal">"\n"</span> and all-space string
|
|
expressions.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar @baz{3}</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">blah}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">baz</span><span class="hspace"> </span><span class="RktVal">"3"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{@b{@u[3] @u{4}}</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">blah}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">b</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">u</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">u</span><span class="hspace"> </span><span class="RktVal">"4"</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@C{while (*(p++))</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">*p = '\n';}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">C</span><span class="hspace"> </span><span class="RktVal">"while (*(p++))"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"*p = '\\n';"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>The command part of an <font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font> is optional as well. In that case,
|
|
the <font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font> is read as a list, which usually counts as a function
|
|
application, but it also useful when quoted with the usual Racket
|
|
<span class="RktSym"><span class="badlink"><span class="RktValLink">quote</span></span></span>:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{blah blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktVal">"blah blah"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{blah @[3]}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktVal">"blah "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">'@{foo</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="RktVal">)</span></td></tr></table></td></tr></table></p><p>Finally, we can also drop the datum and text parts, which leaves us with
|
|
only the command—<wbr></wbr>which is read as is, not within a parenthesized
|
|
form. This is not useful when reading Racket code, but it can be used
|
|
inside a text block to escape a Racket identifier. A vertical bar
|
|
(<span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span>) can be used to delimit the escaped identifier when
|
|
needed.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktSym">foo</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{blah @foo blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktVal">"blah "</span><span class="hspace"> </span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" blah"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{blah @foo: blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktVal">"blah "</span><span class="hspace"> </span><span class="RktSym">foo:</span><span class="hspace"> </span><span class="RktVal">" blah"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@{blah @|foo|: blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktVal">"blah "</span><span class="hspace"> </span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">": blah"</span><span class="RktPn">)</span></td></tr></table></p><p>Actually, the command part can be any Racket expression (that does not
|
|
start with <span class="RktInBG"><span class="hspace"></span><span class="RktIn">[</span><span class="hspace"></span></span>, <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span>, or <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span>), which is
|
|
particularly useful with such escapes since they can be used with any
|
|
expression.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{(+ 1 2) -> @(+ 1 2)!}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"(+ 1 2) -> "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">+</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"!"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{A @"string" escape}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"A string escape"</span><span class="RktPn">)</span></td></tr></table></p><p>Note that an escaped Racket string is merged with the surrounding text
|
|
as a special case. This is useful if you want to use the special
|
|
characters in your string, but escaping braces are not necessary if
|
|
they are balanced.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{eli@"@"barzilay.org}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"eli@barzilay.org"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{A @"{" begins a block}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"A { begins a block"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@C{while (*(p++)) {</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">*p = '\n';</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">}}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">C</span><span class="hspace"> </span><span class="RktVal">"while (*(p++)) {"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"*p = '\\n';"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"}"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>In some cases, a text contains many literal ◊s, which can be
|
|
cumbersome to quote individually. For such case, braces have an
|
|
alternative syntax: A block of text can begin with a
|
|
“<span class="RktInBG"><span class="hspace"></span><span class="RktIn">|{</span><span class="hspace"></span></span>” and terminated accordingly with a
|
|
“<span class="RktInBG"><span class="hspace"></span><span class="RktIn">}|</span><span class="hspace"></span></span>”. Furthermore, any nested <font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font> must begin
|
|
with a “<span class="RktInBG"><span class="hspace"></span><span class="RktIn">|@</span><span class="hspace"></span></span>”.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{bar}@{baz}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar}@{baz"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{bar |@x{X} baz}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktVal">"X"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" baz"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{bar |@x|{@}| baz}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktVal">"@"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" baz"</span><span class="RktPn">)</span></td></tr></table></p><p>In cases when even this is not convenient enough, punctuation
|
|
characters can be added between the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span> and the braces and the
|
|
◊ in nested forms. (The punctuation is mirrored for parentheses
|
|
and <span class="RktInBG"><span class="hspace"></span><span class="RktIn"><></span><span class="hspace"></span></span>s.) With this extension, Pollen syntax can be used as a
|
|
“here string” replacement.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|--{bar}@|{baz}--|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar}@|{baz"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|<<{bar}@|{baz}>>|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar}@|{baz"</span><span class="RktPn">)</span></td></tr></table></p><p>On the flip side of this is, how can an ◊ sign be used in Racket
|
|
code? This is almost never an issue, because Racket strings and
|
|
characters are still read the same, and <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> is set as a
|
|
non-terminating reader macro so it can be used in Racket identifiers
|
|
anywhere except in the first character of an identifier. When
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> must appear as the first character of an identifier, you
|
|
must quote the identifier just like other non-standard characters in
|
|
normal S-expression syntax: with a backslash or with vertical bars.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">(define \@email "foo@bar.com")</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">define</span><span class="hspace"> </span><span class="RktSym">@email</span><span class="hspace"> </span><span class="RktVal">"foo@bar.com"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">(define |@atchar| #\@)</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">define</span><span class="hspace"> </span><span class="RktSym">@atchar</span><span class="hspace"> </span><span class="RktVal">#\@</span><span class="RktPn">)</span></td></tr></table></p><p>Note that spaces are not allowed before a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">[</span><span class="hspace"></span></span> or a
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span>, or they will be part of the following text (or Racket
|
|
code). (More on using braces in body texts below.)</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar @baz[2 3] {4 5}}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">baz</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" {4 5}"</span><span class="RktPn">)</span></td></tr></table></p><p>Finally, remember that the Pollen is just an alternate for
|
|
S-expressions. Identifiers still get their meaning, as in any
|
|
Racket code, through the lexical context in which they appear.
|
|
Specifically, when the above <font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font> appears in a Racket expression
|
|
context, the lexical environment must provide bindings for
|
|
<span class="RktSym">foo</span> as a procedure or a macro; it can be defined, required,
|
|
or bound locally (with <span class="RktSym"><span class="badlink"><span class="RktValLink">let</span></span></span>, for example).</p><blockquote class="SCodeFlow"><table cellspacing="0" class="RktBlk"><tr><td><table cellspacing="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">let*</span></span></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">formatter</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">lambda</span></span></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">fmt</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">lambda</span></span></span><span class="hspace"> </span><span class="RktSym">args</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">format</span></span></span><span class="hspace"> </span><span class="RktSym">fmt</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><span class="badlink"><span class="RktValLink">apply</span></span></span><span class="hspace"> </span><span class="RktSym"><span class="badlink"><span class="RktValLink">string-append</span></span></span><span class="hspace"> </span><span class="RktSym">args</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">bf</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">formatter</span><span class="hspace"> </span><span class="RktVal">"*~a*"</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">it</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">formatter</span><span class="hspace"> </span><span class="RktVal">"/~a/"</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">ul</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">formatter</span><span class="hspace"> </span><span class="RktVal">"_~a_"</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">text</span><span class="hspace"> </span><span class="RktSym"><span class="badlink"><span class="RktValLink">string-append</span></span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="stt">@text{@it{Note}: @bf{This is @ul{not} a pipe}.}</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">"/Note/: *This is _not_ a pipe*."</span></p></td></tr></table></blockquote><h3>4<tt> </tt><a name="(part._.The_.Datum_.Part)"></a>The Datum Part</h3><p>The datum part can contains arbitrary Racket expressions, which
|
|
are simply stacked before the body text arguments:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[1 (* 2 3)]{bar}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">*</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[@bar{...}]{blah}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">"..."</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr></table></p><p>The body part can still be omitted, which is essentially an
|
|
alternative syntax for plain (non-textual) S-expressions:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[bar]</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktSym">bar</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar @f[x] baz}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" baz"</span><span class="RktPn">)</span></td></tr></table></p><p>The datum part can be empty, which makes no difference, except when
|
|
the body is omitted. It is more common, however, to use an empty body
|
|
for the same purpose.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[]{bar}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[]</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktSym">foo</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="RktPn">)</span></td></tr></table></p><p>The most common use of the datum part is for Racket forms that expect
|
|
keyword-value arguments that precede the body of text arguments.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[#:style 'big]{bar}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktPn">#:style</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">big</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr></table></p><h3>5<tt> </tt><a name="(part._.The_.Body_.Part)"></a>The Body Part</h3><p>The syntax of the body part is intended to be as convenient as
|
|
possible for free text. It can contain almost any text—<wbr></wbr>the only
|
|
characters with special meaning is <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> for sub-<font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font>,
|
|
and <span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span> for the end of the text. In addition, a
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span> is allowed as part of the text, and it makes the
|
|
matching <span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span> be part of the text too—<wbr></wbr>so balanced braces
|
|
are valid text.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{f{o}o}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"f{o}o"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{{{}}{}}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"{{}}{}"</span><span class="RktPn">)</span></td></tr></table></p><p>As described above, the text turns to a sequence of string arguments
|
|
for the resulting form. Spaces at the beginning and end of lines are
|
|
discarded, and newlines turn to individual <span class="RktVal">"\n"</span> strings
|
|
(i.e., they are not merged with other body parts); see also the
|
|
information about newlines and indentation below. Spaces are
|
|
<span style="font-style: italic">not</span> discarded if they appear after the open <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span>
|
|
(before the closing <span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span>) when there is also text that
|
|
follows (precedes) it; specifically, they are preserved in a
|
|
single-line body.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar }</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar "</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo[1]{ bar }</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">" bar "</span><span class="RktPn">)</span></td></tr></table></p><p>If <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> appears in a body, then it is interpreted as Racket
|
|
code, which means that the ◊-reader is applied recursively, and the
|
|
resulting syntax appears as part of the S-expression, among other
|
|
string contents.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{a @bar{b} c}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"a "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">"b"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" c"</span><span class="RktPn">)</span></td></tr></table></p><p>If the nested ◊ construct has only a command—<wbr></wbr>no body or datum
|
|
parts—<wbr></wbr>it will not appear in a subform. Given that the command part
|
|
can be any Racket expression, this makes ◊ a general escape to
|
|
arbitrary Racket code.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{a @bar c}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"a "</span><span class="hspace"> </span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">" c"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{a @(bar 2) c}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"a "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" c"</span><span class="RktPn">)</span></td></tr></table></p><p>This is particularly useful with strings, which can be used to include
|
|
arbitrary text.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{A @"}" marks the end}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"A } marks the end"</span><span class="RktPn">)</span></td></tr></table></p><p>Note that the escaped string is (intentionally) merged with the rest
|
|
of the text. This works for <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> too:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{The prefix: @"@".}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"The prefix: @."</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{@"@x{y}" --> (x "y")}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"@x{y} --> (x \"y\")"</span><span class="RktPn">)</span></td></tr></table></p><h4>5.1<tt> </tt><a name="(part._alt-body-syntax)"></a>Alternative Body Syntax</h4><p>In addition to the above, there is an alternative syntax for the body,
|
|
one that specifies a new marker for its end: use <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|{</span><span class="hspace"></span></span> for
|
|
the opening marker to have the text terminated by a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">}|</span><span class="hspace"></span></span>.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{...}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"..."</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{"}" follows "{"}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"\"}\" follows \"{\""</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{Nesting |{is}| ok}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"Nesting |{is}| ok"</span><span class="RktPn">)</span></td></tr></table></p><p>This applies to sub-<font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font> too—<wbr></wbr>the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> must be
|
|
prefixed with a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span>:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|{Maze</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">|@bar{is}</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">Life!}|</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"Maze"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">"is"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"Life!"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@t|{In |@i|{sub|@"@"s}| too}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">t</span><span class="hspace"> </span><span class="RktVal">"In "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">i</span><span class="hspace"> </span><span class="RktVal">"sub@s"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">" too"</span><span class="RktPn">)</span></td></tr></table></p><p>Note that the subform uses its own delimiters, <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{...}</span><span class="hspace"></span></span> or
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">|{...}|</span><span class="hspace"></span></span>. This means that you can copy and paste Pollen
|
|
text with <font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font> freely, just prefix the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span> if the
|
|
immediate surrounding text has a prefix.</p><p>For even better control, you can add characters in the opening
|
|
delimiter, between the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span> and the <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span>.
|
|
Characters that are put there (non alphanumeric ASCII characters only,
|
|
excluding <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span> and <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@</span><span class="hspace"></span></span>) should also be used for
|
|
sub-<font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font>, and the end-of-body marker should have these characters
|
|
in reverse order with paren-like characters (<span class="RktInBG"><span class="hspace"></span><span class="RktIn">(</span><span class="hspace"></span></span>,
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">[</span><span class="hspace"></span></span>, <span class="RktInBG"><span class="hspace"></span><span class="RktIn"><</span><span class="hspace"></span></span>) mirrored.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|<<<{@x{foo} |@{bar}|.}>>>|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"@x{foo} |@{bar}|."</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo|!!{X |!!@b{Y}...}!!|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"X "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">b</span><span class="hspace"> </span><span class="RktVal">"Y"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"..."</span><span class="RktPn">)</span></td></tr></table></p><p>Finally, remember that you can use an expression escape with a Racket
|
|
string for confusing situations. This works well when you only need
|
|
to quote short pieces, and the above works well when you have larger
|
|
multi-line body texts.</p><h4>5.2<tt> </tt><a name="(part._.Racket_.Expression_.Escapes)"></a>Racket Expression Escapes</h4><p>In some cases, you may want to use a Racket identifier (or a number or
|
|
a boolean etc.) in a position that touches the following text; in
|
|
these situations you should surround the escaped Racket expression by
|
|
a pair of <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span> characters. The text inside the bars is
|
|
parsed as a Racket expression.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{foo@bar.}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktSym">bar.</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{foo@|bar|.}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">"."</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{foo@3.}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktVal">3.0</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{foo@|3|.}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">"."</span><span class="RktPn">)</span></td></tr></table></p><p>This form is a generic Racket expression escape, there is no body text
|
|
or datum part when you use this form.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{foo@|(f 1)|{bar}}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"{bar}"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{foo@|bar|[1]{baz}}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"foo"</span><span class="hspace"> </span><span class="RktSym">bar</span><span class="hspace"> </span><span class="RktVal">"[1]{baz}"</span><span class="RktPn">)</span></td></tr></table></p><p>This works for string expressions too, but note that unlike the above,
|
|
the string is (intentionally) not merged with the rest of the text:</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x@"y"z}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"xyz"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x@|"y"|z}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"x"</span><span class="hspace"> </span><span class="RktVal">"y"</span><span class="hspace"> </span><span class="RktVal">"z"</span><span class="RktPn">)</span></td></tr></table></p><p>Expression escapes also work with <span style="font-style: italic">any</span> number of expressions,</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x@|1 (+ 2 3) 4|y}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"x"</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">+</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">4</span><span class="hspace"> </span><span class="RktVal">"y"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x@|*</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">*|y}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"x"</span><span class="hspace"> </span><span class="RktSym">*</span></td></tr><tr><td><span class="hspace"> </span><span class="RktSym">*</span><span class="hspace"> </span><span class="RktVal">"y"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>It seems that <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@||</span><span class="hspace"></span></span> has no purpose—<wbr></wbr>but remember that these escapes
|
|
are never merged with the surrounding text, which can be useful when
|
|
you want to control the sub expressions in the form.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{Alice@||Bob@|</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">|Carol}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"Alice"</span><span class="hspace"> </span><span class="RktVal">"Bob"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"Carol"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>Note that <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@|{...}|</span><span class="hspace"></span></span> can be parsed as either an escape expression or
|
|
as the Racket command part of an <font class="badlink"><span class="techoutside"><span class="techinside">◊-form</span></span></font>. The latter is used in this case
|
|
(since there is little point in Racket code that uses braces.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@|{blah}|</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr></table></p><h4>5.3<tt> </tt><a name="(part._.Comments)"></a>Comments</h4><p>As noted above, there are two kinds of Pollen comments: <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@;{...}</span><span class="hspace"></span></span> is
|
|
a (nestable) comment for a whole body of text (following the same
|
|
rules for <font class="badlink"><span class="techoutside"><span class="techinside">◊-forms</span></span></font>), and <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@;...</span><span class="hspace"></span></span> is a line-comment.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{First line@;{there is still a</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">newline here;}</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">Second line}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"First line"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"Second line"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>One useful property of line-comments is that they continue to the end
|
|
of the line <span style="font-style: italic">and</span> all following spaces (or tabs). Using this,
|
|
you can get further control of the subforms.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{A long @;</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">single-@;</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">string arg.}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"A long single-string arg."</span><span class="RktPn">)</span></td></tr></table></p><p>Note how this is different from using <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@||</span><span class="hspace"></span></span>s in that strings
|
|
around it are not merged.</p><h4>5.4<tt> </tt><a name="(part._.Spaces__.Newlines__and_.Indentation)"></a>Spaces, Newlines, and Indentation</h4><p>The Pollen syntax treats spaces and newlines in a special way is
|
|
meant to be sensible for dealing with text. As mentioned above,
|
|
spaces at the beginning and end of body lines are discarded, except
|
|
for spaces between a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span> and text, or between text and a
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span>.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar}</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar }</span><span class="hspace"></span></span></p></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar "</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz }</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz "</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>A single newline that follows an open brace or precedes a closing
|
|
brace is discarded, unless there are only newlines in the body; other
|
|
newlines are read as a <span class="RktVal">"\n"</span> string</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p> </p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p> </p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p> </p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p> </p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz }</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz "</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>Spaces at the beginning of body lines do not appear in the resulting
|
|
S-expressions, but the column of each line is noticed, and all-space
|
|
indentation strings are added so the result has the same indentation.
|
|
A indentation string is added to each line according to its distance
|
|
from the leftmost syntax object (except for empty lines). (Note: if
|
|
you try these examples on a Racket REPL, you should be aware that
|
|
the reader does not know about the “<span class="RktInBG"><span class="hspace"></span><span class="RktIn">></span><span class="hspace"> </span></span>” prompt.)</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">blah</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"blah"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">begin</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">x++;</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">end}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"begin"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"x++;"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"end"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">a</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">b</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">c}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"a"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">" "</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"b"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"c"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>If the first string came from the opening <span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span> line, it is
|
|
not prepended with an indentation (but it can affect the leftmost
|
|
syntax object used for indentation). This makes sense when formatting
|
|
structured code as well as text (see the last example in the following
|
|
block).</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bbb}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bbb"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bbb}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">" "</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bbb"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bbb}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">"bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bbb"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bbb}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bbb"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{ bar</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">baz</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">bbb}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span><span class="hspace"> </span><span class="RktVal">" bar"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"baz"</span><span class="hspace"> </span><span class="RktVal">"\n"</span><span class="hspace"> </span><span class="RktVal">"</span><span class="hspace"> </span><span class="RktVal">"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"bbb"</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><p></p></td><td><p></p></td><td><p></p></td></tr><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@text{Some @b{bold</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">text}, and</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">more text.}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">text</span><span class="hspace"> </span><span class="RktVal">"Some "</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">b</span><span class="hspace"> </span><span class="RktVal">"bold"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"text"</span><span class="RktPn">)</span><span class="RktVal">", and"</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">"more text."</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p><p>Note that each ◊-form is parsed to an S-expression that has its own
|
|
indentation. This means that Pollen source can be indented like
|
|
code, but if indentation matters then you may need to apply
|
|
indentation of the outer item to all lines of the inner one. For
|
|
example, in</p><p><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@code{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">begin</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">i = 1, r = 1</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">@bold{while i < n do</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">r *= i++</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">done}</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">end</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span></p></td></tr></table></p><p>a formatter will need to apply the 2-space indentation to the
|
|
rendering of the <span class="RktSym"><span class="badlink"><span class="RktValLink">bold</span></span></span> body.</p><p>Note that to get a first-line text to be counted as a leftmost line,
|
|
line and column accounting should be on for the input port
|
|
(<span class="RktSym"><span class="badlink"><span class="RktValLink">use-at-readtable</span></span></span> turns them on for the current input port).
|
|
Without this,</p><p><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x1</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">x2</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">x3}</span><span class="hspace"></span></span></p></td></tr></table></p><p>will not have 2-space indentations in the parsed S-expression if
|
|
source accounting is not on, but</p><p><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{x1</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">x2</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">x3}</span><span class="hspace"></span></span></p></td></tr></table></p><p>will (due to the last line). Pay attention to this, as it can be a
|
|
problem with Racket code, for example:</p><p><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@code{(define (foo x)</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">(+ x 1))}</span><span class="hspace"></span></span></p></td></tr></table></p><p>For rare situations where spaces at the beginning (or end) of lines
|
|
matter, you can begin (or end) a line with a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">@||</span><span class="hspace"></span></span>.</p><p><table cellspacing="0"><tr><td><p><span class="hspace"> </span></p></td><td><table cellspacing="0"><tr><td><p><span class="RktInBG"><span class="hspace"></span><span class="RktIn">@foo{</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">@|| bar @||</span><span class="hspace"></span></span></p></td></tr><tr><td><p><span class="RktInBG"><span class="hspace"> </span><span class="RktIn">@|| baz}</span><span class="hspace"></span></span></p></td></tr></table></td><td><p><span class="hspace"> </span>reads as<span class="hspace"> </span></p></td><td><table cellspacing="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">foo</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">" bar "</span><span class="hspace"> </span><span class="RktVal">"\n"</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">" baz"</span><span class="RktPn">)</span></td></tr></table></td></tr></table></p></div></div><div id="contextindicator"> </div></body></html> |