{
	"0: data": {
		"srcIndexStart": "0", 
		"file": "docssrc/docs.APIOver.tmpl", 
		"parseTreeMode": "true", 
		"srcLength": "4472", 
		"source": "[$name|APIOver$]
[$title|GoldieLib Overview$]
[$frame|HTMLPage.tmpl$]
<a name=\"Overview\" />

<p>
[$ident|GoldieLib$] is Goldie's
[$link| http://www.d-programming-language.org/ | D $]
API. Using GoldieLib, your D programs
can parse text according to any GOLD-compatible grammar and access
some of Goldie's other capabilities.
</p>

<a name=\"Import\" />
<h2>Importing</h2>

<p>Importing is simple:</p>

[$code|highlight|
[:import goldie.all;
:]$]

<p>
When you compile, make sure to tell the compiler where to find
Goldie and SemiTwist D Tools:
</p>

<div class=\"code-plain\">&gt;[$code|user|
	rdmd --build-only -I{path to SemiTwistDTools}/src -I{path to Goldie}/src myMain.d
$]</div>


<h2>Conventions Used By GoldieLib</h2>

<a name=\"LineColumn\" />
<h3>Line and Column Numbers</h3>
<p>
All line numbers and column numbers are internally stored and treated
by the API as zero-indexed and displayed to the user as one-indexed.
</p>

<p>
When Goldie refers to a \"column number\", it really means \"the number of
characters (ie, UTF code-points) from the start of the line\". 
This behavior is more reliable and more useful than a true \"column number\"
because:
</p>
<ul>
<li>
	Tab-size is a matter of presentation (For better or worse, depending on one's perspective).
</li>
<li>
	Non-printing characters may exist in a source to be parsed.
</li>
<li>
	The increasingly popular concept of
	[$link|http://nickgravgaard.com/elastictabstops/|elastic tabstops$]
	makes proportional fonts practical for source code, which renders
	the traditional concept of \"column number\" meaningless.
</li>
</ul>

<a name=\"TokenSymbol\" />
<h3>
	Tokens, Symbols, and Symbol Types:<br />
	<span style=\"font-size: 0.9em\">The Front-End's Building Blocks</span>
</h3>
<p>
A [$typeName|Token$] can be thought of as an instance of a [$typeName|Symbol$].
A [$typeName|Token$] is part of the parsed source, and a [$typeName|Symbol$]
is part of the grammar.
</p>
<p>
For example, consider this grammar:
</p>

[$code|plain|
[:Word = {Letter}+
<Sentence> ::= <Sentence> Word
:]$]

<p>
And this source:
</p>

[$code|plain|
[:Hello world
:]$]
<p>
These are the Tokens and Symbols:
</p>
<table class=\"grid-table\">
<tr><td>[$ident|Word$]</td><td>[$typeName|Symbol$]</td><td>This Symbol's type is [$typeName|SymbolType$][$ident|.Terminal$].</td></tr>
<tr><td>[$ident|&lt;Sentence&gt;$]</td><td>[$typeName|Symbol$]</td><td>This Symbol's type is [$typeName|SymbolType$][$ident|.NonTerminal$].</td></tr>
<tr><td>[$ident|Hello$]</td><td>[$typeName|Token$]</td><td>This Token's Symbol is [$ident|Word$].</td></tr>
<tr><td>[$ident|world$]</td><td>[$typeName|Token$]</td><td>This Token's Symbol is [$ident|Word$].</td></tr>
<tr><td>[$ident|Hello world$]</td><td>[$typeName|Token$]</td><td>This Token's Symbol is [$ident|&lt;Sentence&gt;$].</td></tr>
</table>
<p>
Note that Goldie defines more symbol types
than just [$ident|Terminal$] and [$ident|NonTerminal$] (see the
[$typeName|SymbolType$] documentation).
So if you want to check if a Symbol or Token is a [$ident|SymbolType.NonTerminal$]
do NOT do it by comparing the type with [$ident|SymbolType.Terminal$]. Just because
something isn't a [$ident|SymbolType.Terminal$] does NOT imply that
it's a [$ident|SymbolType.NonTerminal$].
</p>

<a name=\"EmptyRule\" />
<h2>Referring to a rule that has no subtokens</h2>
<p>
Just use [$ident|null$] for the subtokens.
</p>
<p>
Example:
</p>
<p>
Suppose you have this in your grammar for language \"myLang\":
</p>
[$code|plain|
[:<Optional Fred> ::= 'fred'
                  | :]
$]
<p>
The nonterminal [$ident|&lt;Optional Fred&gt;$] can be created from either the
text [$ident|fred$] or from nothing at all. To check if a token matches the
first case, ie. the [$ident|fred$] rule, you use this:
</p>
[$code|highlight|
[:// static-style: 
if( auto typedTok = cast(Token_myLang!(\"<Optional Fred>\", \"fred\"))token )
{
	// use typedTok
}

// dynamic-style: 
if( token.matches(\"<Optional Fred>\", \"fred\") )
{
	// use token
}:]
$]
<p>
To check for the empty rule, you just use [$ident|null$]:
</p>
[$code|highlight|
[:// static-style: 
if( auto typedTok = cast(Token_myLang!(\"<Optional Fred>\", null))token )
{
	// use typedTok
}

// dynamic-style: 
if( token.matches(\"<Optional Fred>\", null) )
{
	// use token
}:]
$]

<h2>Simple Examples</h2>
<p>
For simple examples of how to use GoldieLib, see the [$pageTitle|SampleApps$].
</p>

<h3 class=\"list-heading\">See Also:</h3>
<ul>
<li>[$pageLink|APIRef| GoldieLib API Reference $]</li>
</ul>
", 
		"0: name": {
			"srcIndexStart": "0", 
			"data": "APIOver", 
			"srcLength": "16", 
			"0: data": {
				"srcIndexStart": "7", 
				"data": "APIOver", 
				"srcLength": "7"
			}
		}, 
		"1: data": {
			"srcIndexStart": "16", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"2: title": {
			"srcIndexStart": "17", 
			"data": "GoldieLib Overview", 
			"srcLength": "28", 
			"0: data": {
				"srcIndexStart": "25", 
				"data": "GoldieLib Overview", 
				"srcLength": "18"
			}
		}, 
		"3: data": {
			"srcIndexStart": "45", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"4: frame": {
			"srcIndexStart": "46", 
			"data": "HTMLPage.tmpl", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "54", 
				"data": "HTMLPage.tmpl", 
				"srcLength": "13"
			}
		}, 
		"5: data": {
			"srcIndexStart": "69", 
			"data": "
<a name=\"Overview\" />

<p>
", 
			"srcLength": "28"
		}, 
		"6: ident": {
			"srcIndexStart": "97", 
			"data": "GoldieLib", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "105", 
				"data": "GoldieLib", 
				"srcLength": "9"
			}
		}, 
		"7: data": {
			"srcIndexStart": "116", 
			"data": " is Goldie's
", 
			"srcLength": "13"
		}, 
		"8: link": {
			"srcIndexStart": "129", 
			"param 0": "http://www.d-programming-language.org/", 
			"data": "D", 
			"srcLength": "53", 
			"0: data": {
				"srcIndexStart": "177", 
				"data": "D", 
				"srcLength": "3"
			}
		}, 
		"9: data": {
			"srcIndexStart": "182", 
			"data": "
API. Using GoldieLib, your D programs
can parse text according to any GOLD-compatible grammar and access
some of Goldie's other capabilities.
</p>

<a name=\"Import\" />
<h2>Importing</h2>

<p>Importing is simple:</p>

", 
			"srcLength": "218"
		}, 
		"10: code": {
			"srcIndexStart": "400", 
			"param 0": "highlight", 
			"data": "import goldie.all;
", 
			"srcLength": "43", 
			"0: data": {
				"srcIndexStart": "417", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "418", 
				"data": "import goldie.all;
", 
				"srcLength": "23"
			}
		}, 
		"11: data": {
			"srcIndexStart": "443", 
			"data": "

<p>
When you compile, make sure to tell the compiler where to find
Goldie and SemiTwist D Tools:
</p>

<div class=\"code-plain\">&gt;", 
			"srcLength": "133"
		}, 
		"12: code": {
			"srcIndexStart": "576", 
			"param 0": "user", 
			"data": "rdmd --build-only -I{path to SemiTwistDTools}/src -I{path to Goldie}/src myMain.d", 
			"srcLength": "98", 
			"0: data": {
				"srcIndexStart": "588", 
				"data": "rdmd --build-only -I{path to SemiTwistDTools}/src -I{path to Goldie}/src myMain.d", 
				"srcLength": "84"
			}
		}, 
		"13: data": {
			"srcIndexStart": "674", 
			"data": "</div>


<h2>Conventions Used By GoldieLib</h2>

<a name=\"LineColumn\" />
<h3>Line and Column Numbers</h3>
<p>
All line numbers and column numbers are internally stored and treated
by the API as zero-indexed and displayed to the user as one-indexed.
</p>

<p>
When Goldie refers to a \"column number\", it really means \"the number of
characters (ie, UTF code-points) from the start of the line\". 
This behavior is more reliable and more useful than a true \"column number\"
because:
</p>
<ul>
<li>
	Tab-size is a matter of presentation (For better or worse, depending on one's perspective).
</li>
<li>
	Non-printing characters may exist in a source to be parsed.
</li>
<li>
	The increasingly popular concept of
	", 
			"srcLength": "707"
		}, 
		"14: link": {
			"srcIndexStart": "1381", 
			"param 0": "http://nickgravgaard.com/elastictabstops/", 
			"data": "elastic tabstops", 
			"srcLength": "67", 
			"0: data": {
				"srcIndexStart": "1430", 
				"data": "elastic tabstops", 
				"srcLength": "16"
			}
		}, 
		"15: data": {
			"srcIndexStart": "1448", 
			"data": "
	makes proportional fonts practical for source code, which renders
	the traditional concept of \"column number\" meaningless.
</li>
</ul>

<a name=\"TokenSymbol\" />
<h3>
	Tokens, Symbols, and Symbol Types:<br />
	<span style=\"font-size: 0.9em\">The Front-End's Building Blocks</span>
</h3>
<p>
A ", 
			"srcLength": "293"
		}, 
		"16: typeName": {
			"srcIndexStart": "1741", 
			"data": "Token", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "1752", 
				"data": "Token", 
				"srcLength": "5"
			}
		}, 
		"17: data": {
			"srcIndexStart": "1759", 
			"data": " can be thought of as an instance of a ", 
			"srcLength": "39"
		}, 
		"18: typeName": {
			"srcIndexStart": "1798", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "1809", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"19: data": {
			"srcIndexStart": "1817", 
			"data": ".
A ", 
			"srcLength": "4"
		}, 
		"20: typeName": {
			"srcIndexStart": "1821", 
			"data": "Token", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "1832", 
				"data": "Token", 
				"srcLength": "5"
			}
		}, 
		"21: data": {
			"srcIndexStart": "1839", 
			"data": " is part of the parsed source, and a ", 
			"srcLength": "37"
		}, 
		"22: typeName": {
			"srcIndexStart": "1876", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "1887", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"23: data": {
			"srcIndexStart": "1895", 
			"data": "
is part of the grammar.
</p>
<p>
For example, consider this grammar:
</p>

", 
			"srcLength": "76"
		}, 
		"24: code": {
			"srcIndexStart": "1971", 
			"param 0": "plain", 
			"data": "Word = {Letter}+
&lt;Sentence&gt; ::= &lt;Sentence&gt; Word
", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "1984", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "1985", 
				"data": "Word = {Letter}+
<Sentence> ::= <Sentence> Word
", 
				"srcLength": "52"
			}
		}, 
		"25: data": {
			"srcIndexStart": "2039", 
			"data": "

<p>
And this source:
</p>

", 
			"srcLength": "29"
		}, 
		"26: code": {
			"srcIndexStart": "2068", 
			"param 0": "plain", 
			"data": "Hello world
", 
			"srcLength": "32", 
			"0: data": {
				"srcIndexStart": "2081", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "2082", 
				"data": "Hello world
", 
				"srcLength": "16"
			}
		}, 
		"27: data": {
			"srcIndexStart": "2100", 
			"data": "
<p>
These are the Tokens and Symbols:
</p>
<table class=\"grid-table\">
<tr><td>", 
			"srcLength": "79"
		}, 
		"28: ident": {
			"srcIndexStart": "2179", 
			"data": "Word", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "2187", 
				"data": "Word", 
				"srcLength": "4"
			}
		}, 
		"29: data": {
			"srcIndexStart": "2193", 
			"data": "</td><td>", 
			"srcLength": "9"
		}, 
		"30: typeName": {
			"srcIndexStart": "2202", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "2213", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"31: data": {
			"srcIndexStart": "2221", 
			"data": "</td><td>This Symbol's type is ", 
			"srcLength": "31"
		}, 
		"32: typeName": {
			"srcIndexStart": "2252", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "2263", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"33: ident": {
			"srcIndexStart": "2275", 
			"data": ".Terminal", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "2283", 
				"data": ".Terminal", 
				"srcLength": "9"
			}
		}, 
		"34: data": {
			"srcIndexStart": "2294", 
			"data": ".</td></tr>
<tr><td>", 
			"srcLength": "20"
		}, 
		"35: ident": {
			"srcIndexStart": "2314", 
			"data": "&lt;Sentence&gt;", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "2322", 
				"data": "&lt;Sentence&gt;", 
				"srcLength": "16"
			}
		}, 
		"36: data": {
			"srcIndexStart": "2340", 
			"data": "</td><td>", 
			"srcLength": "9"
		}, 
		"37: typeName": {
			"srcIndexStart": "2349", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "2360", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"38: data": {
			"srcIndexStart": "2368", 
			"data": "</td><td>This Symbol's type is ", 
			"srcLength": "31"
		}, 
		"39: typeName": {
			"srcIndexStart": "2399", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "2410", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"40: ident": {
			"srcIndexStart": "2422", 
			"data": ".NonTerminal", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "2430", 
				"data": ".NonTerminal", 
				"srcLength": "12"
			}
		}, 
		"41: data": {
			"srcIndexStart": "2444", 
			"data": ".</td></tr>
<tr><td>", 
			"srcLength": "20"
		}, 
		"42: ident": {
			"srcIndexStart": "2464", 
			"data": "Hello", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "2472", 
				"data": "Hello", 
				"srcLength": "5"
			}
		}, 
		"43: data": {
			"srcIndexStart": "2479", 
			"data": "</td><td>", 
			"srcLength": "9"
		}, 
		"44: typeName": {
			"srcIndexStart": "2488", 
			"data": "Token", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "2499", 
				"data": "Token", 
				"srcLength": "5"
			}
		}, 
		"45: data": {
			"srcIndexStart": "2506", 
			"data": "</td><td>This Token's Symbol is ", 
			"srcLength": "32"
		}, 
		"46: ident": {
			"srcIndexStart": "2538", 
			"data": "Word", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "2546", 
				"data": "Word", 
				"srcLength": "4"
			}
		}, 
		"47: data": {
			"srcIndexStart": "2552", 
			"data": ".</td></tr>
<tr><td>", 
			"srcLength": "20"
		}, 
		"48: ident": {
			"srcIndexStart": "2572", 
			"data": "world", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "2580", 
				"data": "world", 
				"srcLength": "5"
			}
		}, 
		"49: data": {
			"srcIndexStart": "2587", 
			"data": "</td><td>", 
			"srcLength": "9"
		}, 
		"50: typeName": {
			"srcIndexStart": "2596", 
			"data": "Token", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "2607", 
				"data": "Token", 
				"srcLength": "5"
			}
		}, 
		"51: data": {
			"srcIndexStart": "2614", 
			"data": "</td><td>This Token's Symbol is ", 
			"srcLength": "32"
		}, 
		"52: ident": {
			"srcIndexStart": "2646", 
			"data": "Word", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "2654", 
				"data": "Word", 
				"srcLength": "4"
			}
		}, 
		"53: data": {
			"srcIndexStart": "2660", 
			"data": ".</td></tr>
<tr><td>", 
			"srcLength": "20"
		}, 
		"54: ident": {
			"srcIndexStart": "2680", 
			"data": "Hello world", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "2688", 
				"data": "Hello world", 
				"srcLength": "11"
			}
		}, 
		"55: data": {
			"srcIndexStart": "2701", 
			"data": "</td><td>", 
			"srcLength": "9"
		}, 
		"56: typeName": {
			"srcIndexStart": "2710", 
			"data": "Token", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "2721", 
				"data": "Token", 
				"srcLength": "5"
			}
		}, 
		"57: data": {
			"srcIndexStart": "2728", 
			"data": "</td><td>This Token's Symbol is ", 
			"srcLength": "32"
		}, 
		"58: ident": {
			"srcIndexStart": "2760", 
			"data": "&lt;Sentence&gt;", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "2768", 
				"data": "&lt;Sentence&gt;", 
				"srcLength": "16"
			}
		}, 
		"59: data": {
			"srcIndexStart": "2786", 
			"data": ".</td></tr>
</table>
<p>
Note that Goldie defines more symbol types
than just ", 
			"srcLength": "78"
		}, 
		"60: ident": {
			"srcIndexStart": "2864", 
			"data": "Terminal", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "2872", 
				"data": "Terminal", 
				"srcLength": "8"
			}
		}, 
		"61: data": {
			"srcIndexStart": "2882", 
			"data": " and ", 
			"srcLength": "5"
		}, 
		"62: ident": {
			"srcIndexStart": "2887", 
			"data": "NonTerminal", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "2895", 
				"data": "NonTerminal", 
				"srcLength": "11"
			}
		}, 
		"63: data": {
			"srcIndexStart": "2908", 
			"data": " (see the
", 
			"srcLength": "10"
		}, 
		"64: typeName": {
			"srcIndexStart": "2918", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "2929", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"65: data": {
			"srcIndexStart": "2941", 
			"data": " documentation).
So if you want to check if a Symbol or Token is a ", 
			"srcLength": "67"
		}, 
		"66: ident": {
			"srcIndexStart": "3008", 
			"data": "SymbolType.NonTerminal", 
			"srcLength": "32", 
			"0: data": {
				"srcIndexStart": "3016", 
				"data": "SymbolType.NonTerminal", 
				"srcLength": "22"
			}
		}, 
		"67: data": {
			"srcIndexStart": "3040", 
			"data": "
do NOT do it by comparing the type with ", 
			"srcLength": "41"
		}, 
		"68: ident": {
			"srcIndexStart": "3081", 
			"data": "SymbolType.Terminal", 
			"srcLength": "29", 
			"0: data": {
				"srcIndexStart": "3089", 
				"data": "SymbolType.Terminal", 
				"srcLength": "19"
			}
		}, 
		"69: data": {
			"srcIndexStart": "3110", 
			"data": ". Just because
something isn't a ", 
			"srcLength": "33"
		}, 
		"70: ident": {
			"srcIndexStart": "3143", 
			"data": "SymbolType.Terminal", 
			"srcLength": "29", 
			"0: data": {
				"srcIndexStart": "3151", 
				"data": "SymbolType.Terminal", 
				"srcLength": "19"
			}
		}, 
		"71: data": {
			"srcIndexStart": "3172", 
			"data": " does NOT imply that
it's a ", 
			"srcLength": "28"
		}, 
		"72: ident": {
			"srcIndexStart": "3200", 
			"data": "SymbolType.NonTerminal", 
			"srcLength": "32", 
			"0: data": {
				"srcIndexStart": "3208", 
				"data": "SymbolType.NonTerminal", 
				"srcLength": "22"
			}
		}, 
		"73: data": {
			"srcIndexStart": "3232", 
			"data": ".
</p>

<a name=\"EmptyRule\" />
<h2>Referring to a rule that has no subtokens</h2>
<p>
Just use ", 
			"srcLength": "95"
		}, 
		"74: ident": {
			"srcIndexStart": "3327", 
			"data": "null", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "3335", 
				"data": "null", 
				"srcLength": "4"
			}
		}, 
		"75: data": {
			"srcIndexStart": "3341", 
			"data": " for the subtokens.
</p>
<p>
Example:
</p>
<p>
Suppose you have this in your grammar for language \"myLang\":
</p>
", 
			"srcLength": "113"
		}, 
		"76: code": {
			"srcIndexStart": "3454", 
			"param 0": "plain", 
			"data": "&lt;Optional Fred&gt; ::= 'fred'
                  | ", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "3467", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "3468", 
				"data": "<Optional Fred> ::= 'fred'
                  | ", 
				"srcLength": "51"
			}, 
			"2: data": {
				"srcIndexStart": "3519", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"77: data": {
			"srcIndexStart": "3522", 
			"data": "
<p>
The nonterminal ", 
			"srcLength": "21"
		}, 
		"78: ident": {
			"srcIndexStart": "3543", 
			"data": "&lt;Optional Fred&gt;", 
			"srcLength": "31", 
			"0: data": {
				"srcIndexStart": "3551", 
				"data": "&lt;Optional Fred&gt;", 
				"srcLength": "21"
			}
		}, 
		"79: data": {
			"srcIndexStart": "3574", 
			"data": " can be created from either the
text ", 
			"srcLength": "37"
		}, 
		"80: ident": {
			"srcIndexStart": "3611", 
			"data": "fred", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "3619", 
				"data": "fred", 
				"srcLength": "4"
			}
		}, 
		"81: data": {
			"srcIndexStart": "3625", 
			"data": " or from nothing at all. To check if a token matches the
first case, ie. the ", 
			"srcLength": "77"
		}, 
		"82: ident": {
			"srcIndexStart": "3702", 
			"data": "fred", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "3710", 
				"data": "fred", 
				"srcLength": "4"
			}
		}, 
		"83: data": {
			"srcIndexStart": "3716", 
			"data": " rule, you use this:
</p>
", 
			"srcLength": "26"
		}, 
		"84: code": {
			"srcIndexStart": "3742", 
			"param 0": "highlight", 
			"data": "<span class=\"code-comment\">// static-style:</span> 
if( auto typedTok = cast(Token_myLang!(\"&lt;Optional Fred&gt;\", \"fred\"))token )
{
    <span class=\"code-comment\">// use typedTok</span>
}

<span class=\"code-comment\">// dynamic-style:</span> 
if( token.matches(\"&lt;Optional Fred&gt;\", \"fred\") )
{
    <span class=\"code-comment\">// use token</span>
}", 
			"srcLength": "222", 
			"0: data": {
				"srcIndexStart": "3759", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "3760", 
				"data": "// static-style: 
if( auto typedTok = cast(Token_myLang!(\"<Optional Fred>\", \"fred\"))token )
{
	// use typedTok
}

// dynamic-style: 
if( token.matches(\"<Optional Fred>\", \"fred\") )
{
	// use token
}", 
				"srcLength": "201"
			}, 
			"2: data": {
				"srcIndexStart": "3961", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"85: data": {
			"srcIndexStart": "3964", 
			"data": "
<p>
To check for the empty rule, you just use ", 
			"srcLength": "47"
		}, 
		"86: ident": {
			"srcIndexStart": "4011", 
			"data": "null", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "4019", 
				"data": "null", 
				"srcLength": "4"
			}
		}, 
		"87: data": {
			"srcIndexStart": "4025", 
			"data": ":
</p>
", 
			"srcLength": "7"
		}, 
		"88: code": {
			"srcIndexStart": "4032", 
			"param 0": "highlight", 
			"data": "<span class=\"code-comment\">// static-style:</span> 
if( auto typedTok = cast(Token_myLang!(\"&lt;Optional Fred&gt;\", null))token )
{
    <span class=\"code-comment\">// use typedTok</span>
}

<span class=\"code-comment\">// dynamic-style:</span> 
if( token.matches(\"&lt;Optional Fred&gt;\", null) )
{
    <span class=\"code-comment\">// use token</span>
}", 
			"srcLength": "218", 
			"0: data": {
				"srcIndexStart": "4049", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "4050", 
				"data": "// static-style: 
if( auto typedTok = cast(Token_myLang!(\"<Optional Fred>\", null))token )
{
	// use typedTok
}

// dynamic-style: 
if( token.matches(\"<Optional Fred>\", null) )
{
	// use token
}", 
				"srcLength": "197"
			}, 
			"2: data": {
				"srcIndexStart": "4247", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"89: data": {
			"srcIndexStart": "4250", 
			"data": "

<h2>Simple Examples</h2>
<p>
For simple examples of how to use GoldieLib, see the ", 
			"srcLength": "84"
		}, 
		"90: pageTitle": {
			"srcIndexStart": "4334", 
			"data": "SampleApps", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "4346", 
				"data": "SampleApps", 
				"srcLength": "10"
			}
		}, 
		"91: data": {
			"srcIndexStart": "4358", 
			"data": ".
</p>

<h3 class=\"list-heading\">See Also:</h3>
<ul>
<li>", 
			"srcLength": "57"
		}, 
		"92: pageLink": {
			"srcIndexStart": "4415", 
			"param 0": "APIRef", 
			"data": "GoldieLib API Reference", 
			"srcLength": "45", 
			"0: data": {
				"srcIndexStart": "4433", 
				"data": "GoldieLib API Reference", 
				"srcLength": "25"
			}
		}, 
		"93: data": {
			"srcIndexStart": "4460", 
			"data": "</li>
</ul>", 
			"srcLength": "12"
		}
	}
}