{
	"0: data": {
		"srcIndexStart": "0", 
		"file": "docssrc/docs.APIOver.AmbiguousSym.tmpl", 
		"parseTreeMode": "true", 
		"srcLength": "4609", 
		"source": "[$name|AmbiguousSym$]
[$title|Ambiguous Symbols$]
[$frame|HTMLPage.tmpl$]

<p>
[$pageLink| OtherTools#GOLD | GOLD $], and therefore Goldie, 
allows grammars to
have different symbols that share the same name as long as their
[$typeName|SymbolType$] is different. For instance, in this grammar:
</p>
[$code|plain|
[:Foo = {Letter}+
<Foo> ::= Foo:]
$]
<p>
According to GOLD, that is a perfectly legal grammar with two symbols named [$ident|Foo$]:
The first one is a [$typeName|SymbolType$][$ident|.Terminal$],
and the second is a [$typeName|SymbolType$][$ident|.NonTerminal$].
This can cause problems because if you tried to refer to a symbol named [$ident|Foo$],
there are two possible symbols you might mean. Symbol [$ident|Foo$] is ambiguous.
</p>
<p>
Because of this, Goldie considers the angle brackets on nonterminal
to be part of the symbol's name. So in the example above,
the terminal symbol is named [$ident|Foo$], but the nonterminal is named
[$ident|&lt;Foo&gt;$]. In Goldie, a nonterminal's name <em>always</em> includes
the surrounding angle brackets.
</p>
<p>
That usually solves the problem, but there are still cases where it doesn't help, such as these three:
</p>
[$code|plain|
[:<Foo> ::= '<Foo>'
<A> ::= 'EOL'
<B> ::= 'Error':]
$]
<p>
The above is perfectly legal grammar according to GOLD, but there are three
ambiguities:
</p>
<ol>
<li>
	There is a nonterminal named [$ident|&lt;Foo&gt;$] <em>and</em>
	a terminal named [$ident|&lt;Foo&gt;$]. Remember, string literals on
	the right-side of a rule are terminals, and their name is whatever the
	content of the string is.
</li>
<li>
	Every GOLD grammar implicitly has a symbol of type
	[$typeName|SymbolType$][$ident|.EOL$]
	named [$ident|EOL$]. The [$ident|EOL$] terminal above is ambiguous
	with that implicit symbol.
</li>
<li>
	Every GOLD grammar implicitly has a symbol of type
	[$typeName|SymbolType$][$ident|.Error$]
	named [$ident|Error$]. The [$ident|Error$] terminal above is ambiguous
	with that implicit symbol.
</li>
</ol>
<p>
To solve these problems: If you're checking tokens by looking at their symbol name
(ie, [$pageLink|Token#Token_name|Token.name$]), then you'll need to remember to
check that the symbol type (ie, [$pageLink|Token#Token_type|Token.type$]) is also
what you expect.
</p>
<p>
If you're passing a symbol name into a Goldie function or template, Goldie
will raise an error if the symbol name is ambiguous. This will be a
compile-time error for [$pageLink|StatVsDyn|static-style$] and it will be a
run-time Exception for [$pageLink|StatVsDyn|dynamic-style$]. If you get such
an \"ambiguous symbol\" error, you will need to disambiguate.
</p>
<p>
For now, there is no built-in way to disambiguate for [$pageLink|StatVsDyn|dynamic-style$],
you'll have to do it manually by checking the token's [$pageLink|Token#Token_type|type$]. 
</p>
<p>
For [$pageLink|StatVsDyn|static-style$], suppose you have the following in your code:
</p>
[$code|highlight|
[:// Ex #1
Token_mylang!(\"<Foo>\") // Which <Foo>? Terminal or nonterminal?

// Ex #2
Token_mylang!(\"<Foo>\", \"subSymbolOfFoo\") // Which <Foo>? Terminal or nonterminal?

// Ex #3
Token_mylang!(\"<FooParent>\", \"<Foo>\", \";\") // Which <Foo>? Terminal or nonterminal?:]
$]
<p>
If [$ident|&lt;Foo&gt;$] is ambiguous, you can disambiguate like this:
</p>
[$code|highlight|
[:// Ex #1
Token_mylang!(SymbolType.NonTerminal, \"<Foo>\");
// or
Token_mylang!(SymbolType.Terminal, \"<Foo>\");

// Ex #2
// No need to change this. All parameters after the first string are sub-symbols,
// and *only* a SymbolType.NonTerminal can ever have sub-symbols.
Token_mylang!(\"<Foo>\", \"subSymbolOfFoo\")

// Ex #3
Token_mylang!(\"<FooParent>\", Token_mylang!(SymbolType.NonTerminal, \"<Foo>\"), \";\")
// or
Token_mylang!(\"<FooParent>\", Token_mylang!(SymbolType.Terminal, \"<Foo>\"), \";\"):]
$]
<p>
Note that you can always use the disambiguated forms even on symbols that
are not ambiguous.
</p>
<p>
Also, note that using a disambiguated form always refers to the *exact same type*, not merely a separate-but-equivalent type:
</p>
[$code|highlight|
[:// Grammar:
//   \"Start Symbol\" = <Plus>
//   <Plus> ::= '+'

// Terminal token
static assert(
	is( Token_mylang!\"+\" == Token_mylang!(SymbolType.Terminal, \"+\") )
);

// NonTerminal token
static assert(
	is( Token_mylang!\"<Plus>\" == Token_mylang!(SymbolType.NonTerminal, \"<Plus>\") )
);

// Rule token
static assert(
	is(
		Token_mylang!(\"<Plus>\", \"+\") ==
		Token_mylang!(\"<Plus>\", Token_mylang!(SymbolType.Terminal, \"+\"))
	)
);

// Or even:
static assert(
	is(
		Token_mylang!(\"<Plus>\", \"+\") ==
		Token_mylang!(\"<Plus>\", Token_mylang!\"+\"))
	)
);:]
$]
", 
		"0: name": {
			"srcIndexStart": "0", 
			"data": "AmbiguousSym", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "7", 
				"data": "AmbiguousSym", 
				"srcLength": "12"
			}
		}, 
		"1: data": {
			"srcIndexStart": "21", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"2: title": {
			"srcIndexStart": "22", 
			"data": "Ambiguous Symbols", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "30", 
				"data": "Ambiguous Symbols", 
				"srcLength": "17"
			}
		}, 
		"3: data": {
			"srcIndexStart": "49", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"4: frame": {
			"srcIndexStart": "50", 
			"data": "HTMLPage.tmpl", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "58", 
				"data": "HTMLPage.tmpl", 
				"srcLength": "13"
			}
		}, 
		"5: data": {
			"srcIndexStart": "73", 
			"data": "

<p>
", 
			"srcLength": "6"
		}, 
		"6: pageLink": {
			"srcIndexStart": "79", 
			"param 0": "OtherTools#GOLD", 
			"data": "GOLD", 
			"srcLength": "37", 
			"0: data": {
				"srcIndexStart": "108", 
				"data": "GOLD", 
				"srcLength": "6"
			}
		}, 
		"7: data": {
			"srcIndexStart": "116", 
			"data": ", and therefore Goldie, 
allows grammars to
have different symbols that share the same name as long as their
", 
			"srcLength": "109"
		}, 
		"8: typeName": {
			"srcIndexStart": "225", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "236", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"9: data": {
			"srcIndexStart": "248", 
			"data": " is different. For instance, in this grammar:
</p>
", 
			"srcLength": "51"
		}, 
		"10: code": {
			"srcIndexStart": "299", 
			"param 0": "plain", 
			"data": "Foo = {Letter}+
&lt;Foo&gt; ::= Foo", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "312", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "313", 
				"data": "Foo = {Letter}+
<Foo> ::= Foo", 
				"srcLength": "33"
			}, 
			"2: data": {
				"srcIndexStart": "346", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"11: data": {
			"srcIndexStart": "349", 
			"data": "
<p>
According to GOLD, that is a perfectly legal grammar with two symbols named ", 
			"srcLength": "81"
		}, 
		"12: ident": {
			"srcIndexStart": "430", 
			"data": "Foo", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "438", 
				"data": "Foo", 
				"srcLength": "3"
			}
		}, 
		"13: data": {
			"srcIndexStart": "443", 
			"data": ":
The first one is a ", 
			"srcLength": "21"
		}, 
		"14: typeName": {
			"srcIndexStart": "464", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "475", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"15: ident": {
			"srcIndexStart": "487", 
			"data": ".Terminal", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "495", 
				"data": ".Terminal", 
				"srcLength": "9"
			}
		}, 
		"16: data": {
			"srcIndexStart": "506", 
			"data": ",
and the second is a ", 
			"srcLength": "22"
		}, 
		"17: typeName": {
			"srcIndexStart": "528", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "539", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"18: ident": {
			"srcIndexStart": "551", 
			"data": ".NonTerminal", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "559", 
				"data": ".NonTerminal", 
				"srcLength": "12"
			}
		}, 
		"19: data": {
			"srcIndexStart": "573", 
			"data": ".
This can cause problems because if you tried to refer to a symbol named ", 
			"srcLength": "74"
		}, 
		"20: ident": {
			"srcIndexStart": "647", 
			"data": "Foo", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "655", 
				"data": "Foo", 
				"srcLength": "3"
			}
		}, 
		"21: data": {
			"srcIndexStart": "660", 
			"data": ",
there are two possible symbols you might mean. Symbol ", 
			"srcLength": "56"
		}, 
		"22: ident": {
			"srcIndexStart": "716", 
			"data": "Foo", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "724", 
				"data": "Foo", 
				"srcLength": "3"
			}
		}, 
		"23: data": {
			"srcIndexStart": "729", 
			"data": " is ambiguous.
</p>
<p>
Because of this, Goldie considers the angle brackets on nonterminal
to be part of the symbol's name. So in the example above,
the terminal symbol is named ", 
			"srcLength": "179"
		}, 
		"24: ident": {
			"srcIndexStart": "908", 
			"data": "Foo", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "916", 
				"data": "Foo", 
				"srcLength": "3"
			}
		}, 
		"25: data": {
			"srcIndexStart": "921", 
			"data": ", but the nonterminal is named
", 
			"srcLength": "31"
		}, 
		"26: ident": {
			"srcIndexStart": "952", 
			"data": "&lt;Foo&gt;", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "960", 
				"data": "&lt;Foo&gt;", 
				"srcLength": "11"
			}
		}, 
		"27: data": {
			"srcIndexStart": "973", 
			"data": ". In Goldie, a nonterminal's name <em>always</em> includes
the surrounding angle brackets.
</p>
<p>
That usually solves the problem, but there are still cases where it doesn't help, such as these three:
</p>
", 
			"srcLength": "208"
		}, 
		"28: code": {
			"srcIndexStart": "1181", 
			"param 0": "plain", 
			"data": "&lt;Foo&gt; ::= '&lt;Foo&gt;'
&lt;A&gt; ::= 'EOL'
&lt;B&gt; ::= 'Error'", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "1194", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "1195", 
				"data": "<Foo> ::= '<Foo>'
<A> ::= 'EOL'
<B> ::= 'Error'", 
				"srcLength": "51"
			}, 
			"2: data": {
				"srcIndexStart": "1246", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"29: data": {
			"srcIndexStart": "1249", 
			"data": "
<p>
The above is perfectly legal grammar according to GOLD, but there are three
ambiguities:
</p>
<ol>
<li>
	There is a nonterminal named ", 
			"srcLength": "139"
		}, 
		"30: ident": {
			"srcIndexStart": "1388", 
			"data": "&lt;Foo&gt;", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "1396", 
				"data": "&lt;Foo&gt;", 
				"srcLength": "11"
			}
		}, 
		"31: data": {
			"srcIndexStart": "1409", 
			"data": " <em>and</em>
	a terminal named ", 
			"srcLength": "32"
		}, 
		"32: ident": {
			"srcIndexStart": "1441", 
			"data": "&lt;Foo&gt;", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "1449", 
				"data": "&lt;Foo&gt;", 
				"srcLength": "11"
			}
		}, 
		"33: data": {
			"srcIndexStart": "1462", 
			"data": ". Remember, string literals on
	the right-side of a rule are terminals, and their name is whatever the
	content of the string is.
</li>
<li>
	Every GOLD grammar implicitly has a symbol of type
	", 
			"srcLength": "194"
		}, 
		"34: typeName": {
			"srcIndexStart": "1656", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "1667", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"35: ident": {
			"srcIndexStart": "1679", 
			"data": ".EOL", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "1687", 
				"data": ".EOL", 
				"srcLength": "4"
			}
		}, 
		"36: data": {
			"srcIndexStart": "1693", 
			"data": "
	named ", 
			"srcLength": "8"
		}, 
		"37: ident": {
			"srcIndexStart": "1701", 
			"data": "EOL", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "1709", 
				"data": "EOL", 
				"srcLength": "3"
			}
		}, 
		"38: data": {
			"srcIndexStart": "1714", 
			"data": ". The ", 
			"srcLength": "6"
		}, 
		"39: ident": {
			"srcIndexStart": "1720", 
			"data": "EOL", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "1728", 
				"data": "EOL", 
				"srcLength": "3"
			}
		}, 
		"40: data": {
			"srcIndexStart": "1733", 
			"data": " terminal above is ambiguous
	with that implicit symbol.
</li>
<li>
	Every GOLD grammar implicitly has a symbol of type
	", 
			"srcLength": "121"
		}, 
		"41: typeName": {
			"srcIndexStart": "1854", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "1865", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"42: ident": {
			"srcIndexStart": "1877", 
			"data": ".Error", 
			"srcLength": "16", 
			"0: data": {
				"srcIndexStart": "1885", 
				"data": ".Error", 
				"srcLength": "6"
			}
		}, 
		"43: data": {
			"srcIndexStart": "1893", 
			"data": "
	named ", 
			"srcLength": "8"
		}, 
		"44: ident": {
			"srcIndexStart": "1901", 
			"data": "Error", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "1909", 
				"data": "Error", 
				"srcLength": "5"
			}
		}, 
		"45: data": {
			"srcIndexStart": "1916", 
			"data": ". The ", 
			"srcLength": "6"
		}, 
		"46: ident": {
			"srcIndexStart": "1922", 
			"data": "Error", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "1930", 
				"data": "Error", 
				"srcLength": "5"
			}
		}, 
		"47: data": {
			"srcIndexStart": "1937", 
			"data": " terminal above is ambiguous
	with that implicit symbol.
</li>
</ol>
<p>
To solve these problems: If you're checking tokens by looking at their symbol name
(ie, ", 
			"srcLength": "161"
		}, 
		"48: pageLink": {
			"srcIndexStart": "2098", 
			"param 0": "Token#Token_name", 
			"data": "Token.name", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "2126", 
				"data": "Token.name", 
				"srcLength": "10"
			}
		}, 
		"49: data": {
			"srcIndexStart": "2138", 
			"data": "), then you'll need to remember to
check that the symbol type (ie, ", 
			"srcLength": "67"
		}, 
		"50: pageLink": {
			"srcIndexStart": "2205", 
			"param 0": "Token#Token_type", 
			"data": "Token.type", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "2233", 
				"data": "Token.type", 
				"srcLength": "10"
			}
		}, 
		"51: data": {
			"srcIndexStart": "2245", 
			"data": ") is also
what you expect.
</p>
<p>
If you're passing a symbol name into a Goldie function or template, Goldie
will raise an error if the symbol name is ambiguous. This will be a
compile-time error for ", 
			"srcLength": "202"
		}, 
		"52: pageLink": {
			"srcIndexStart": "2447", 
			"param 0": "StatVsDyn", 
			"data": "static-style", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "2468", 
				"data": "static-style", 
				"srcLength": "12"
			}
		}, 
		"53: data": {
			"srcIndexStart": "2482", 
			"data": " and it will be a
run-time Exception for ", 
			"srcLength": "41"
		}, 
		"54: pageLink": {
			"srcIndexStart": "2523", 
			"param 0": "StatVsDyn", 
			"data": "dynamic-style", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "2544", 
				"data": "dynamic-style", 
				"srcLength": "13"
			}
		}, 
		"55: data": {
			"srcIndexStart": "2559", 
			"data": ". If you get such
an \"ambiguous symbol\" error, you will need to disambiguate.
</p>
<p>
For now, there is no built-in way to disambiguate for ", 
			"srcLength": "141"
		}, 
		"56: pageLink": {
			"srcIndexStart": "2700", 
			"param 0": "StatVsDyn", 
			"data": "dynamic-style", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "2721", 
				"data": "dynamic-style", 
				"srcLength": "13"
			}
		}, 
		"57: data": {
			"srcIndexStart": "2736", 
			"data": ",
you'll have to do it manually by checking the token's ", 
			"srcLength": "56"
		}, 
		"58: pageLink": {
			"srcIndexStart": "2792", 
			"param 0": "Token#Token_type", 
			"data": "type", 
			"srcLength": "34", 
			"0: data": {
				"srcIndexStart": "2820", 
				"data": "type", 
				"srcLength": "4"
			}
		}, 
		"59: data": {
			"srcIndexStart": "2826", 
			"data": ". 
</p>
<p>
For ", 
			"srcLength": "16"
		}, 
		"60: pageLink": {
			"srcIndexStart": "2842", 
			"param 0": "StatVsDyn", 
			"data": "static-style", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "2863", 
				"data": "static-style", 
				"srcLength": "12"
			}
		}, 
		"61: data": {
			"srcIndexStart": "2877", 
			"data": ", suppose you have the following in your code:
</p>
", 
			"srcLength": "52"
		}, 
		"62: code": {
			"srcIndexStart": "2929", 
			"param 0": "highlight", 
			"data": "<span class=\"code-comment\">// Ex #1</span>
Token_mylang!(\"&lt;Foo&gt;\") <span class=\"code-comment\">// Which &lt;Foo&gt;? Terminal or nonterminal?</span>

<span class=\"code-comment\">// Ex #2</span>
Token_mylang!(\"&lt;Foo&gt;\", \"subSymbolOfFoo\") <span class=\"code-comment\">// Which &lt;Foo&gt;? Terminal or nonterminal?</span>

<span class=\"code-comment\">// Ex #3</span>
Token_mylang!(\"&lt;FooParent&gt;\", \"&lt;Foo&gt;\", \";\") <span class=\"code-comment\">// Which &lt;Foo&gt;? Terminal or nonterminal?</span>", 
			"srcLength": "283", 
			"0: data": {
				"srcIndexStart": "2946", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "2947", 
				"data": "// Ex #1
Token_mylang!(\"<Foo>\") // Which <Foo>? Terminal or nonterminal?

// Ex #2
Token_mylang!(\"<Foo>\", \"subSymbolOfFoo\") // Which <Foo>? Terminal or nonterminal?

// Ex #3
Token_mylang!(\"<FooParent>\", \"<Foo>\", \";\") // Which <Foo>? Terminal or nonterminal?", 
				"srcLength": "262"
			}, 
			"2: data": {
				"srcIndexStart": "3209", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"63: data": {
			"srcIndexStart": "3212", 
			"data": "
<p>
If ", 
			"srcLength": "8"
		}, 
		"64: ident": {
			"srcIndexStart": "3220", 
			"data": "&lt;Foo&gt;", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "3228", 
				"data": "&lt;Foo&gt;", 
				"srcLength": "11"
			}
		}, 
		"65: data": {
			"srcIndexStart": "3241", 
			"data": " is ambiguous, you can disambiguate like this:
</p>
", 
			"srcLength": "52"
		}, 
		"66: code": {
			"srcIndexStart": "3293", 
			"param 0": "highlight", 
			"data": "<span class=\"code-comment\">// Ex #1</span>
Token_mylang!(SymbolType.NonTerminal, \"&lt;Foo&gt;\");
<span class=\"code-comment\">// or</span>
Token_mylang!(SymbolType.Terminal, \"&lt;Foo&gt;\");

<span class=\"code-comment\">// Ex #2</span>
<span class=\"code-comment\">// No need to change this. All parameters after the first string are sub-symbols,</span>
<span class=\"code-comment\">// and *only* a SymbolType.NonTerminal can ever have sub-symbols.</span>
Token_mylang!(\"&lt;Foo&gt;\", \"subSymbolOfFoo\")

<span class=\"code-comment\">// Ex #3</span>
Token_mylang!(\"&lt;FooParent&gt;\", Token_mylang!(SymbolType.NonTerminal, \"&lt;Foo&gt;\"), \";\")
<span class=\"code-comment\">// or</span>
Token_mylang!(\"&lt;FooParent&gt;\", Token_mylang!(SymbolType.Terminal, \"&lt;Foo&gt;\"), \";\")", 
			"srcLength": "508", 
			"0: data": {
				"srcIndexStart": "3310", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "3311", 
				"data": "// Ex #1
Token_mylang!(SymbolType.NonTerminal, \"<Foo>\");
// or
Token_mylang!(SymbolType.Terminal, \"<Foo>\");

// Ex #2
// No need to change this. All parameters after the first string are sub-symbols,
// and *only* a SymbolType.NonTerminal can ever have sub-symbols.
Token_mylang!(\"<Foo>\", \"subSymbolOfFoo\")

// Ex #3
Token_mylang!(\"<FooParent>\", Token_mylang!(SymbolType.NonTerminal, \"<Foo>\"), \";\")
// or
Token_mylang!(\"<FooParent>\", Token_mylang!(SymbolType.Terminal, \"<Foo>\"), \";\")", 
				"srcLength": "487"
			}, 
			"2: data": {
				"srcIndexStart": "3798", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"67: data": {
			"srcIndexStart": "3801", 
			"data": "
<p>
Note that you can always use the disambiguated forms even on symbols that
are not ambiguous.
</p>
<p>
Also, note that using a disambiguated form always refers to the *exact same type*, not merely a separate-but-equivalent type:
</p>
", 
			"srcLength": "238"
		}, 
		"68: code": {
			"srcIndexStart": "4039", 
			"param 0": "highlight", 
			"data": "<span class=\"code-comment\">// Grammar:</span>
<span class=\"code-comment\">//   \"Start Symbol\" = &lt;Plus&gt;</span>
<span class=\"code-comment\">//   &lt;Plus&gt; ::= '+'</span>

<span class=\"code-comment\">// Terminal token</span>
static assert(
    is( Token_mylang!\"+\" == Token_mylang!(SymbolType.Terminal, \"+\") )
);

<span class=\"code-comment\">// NonTerminal token</span>
static assert(
    is( Token_mylang!\"&lt;Plus&gt;\" == Token_mylang!(SymbolType.NonTerminal, \"&lt;Plus&gt;\") )
);

<span class=\"code-comment\">// Rule token</span>
static assert(
    is(
        Token_mylang!(\"&lt;Plus&gt;\", \"+\") ==
        Token_mylang!(\"&lt;Plus&gt;\", Token_mylang!(SymbolType.Terminal, \"+\"))
    )
);

<span class=\"code-comment\">// Or even:</span>
static assert(
    is(
        Token_mylang!(\"&lt;Plus&gt;\", \"+\") ==
        Token_mylang!(\"&lt;Plus&gt;\", Token_mylang!\"+\"))
    )
);", 
			"srcLength": "569", 
			"0: data": {
				"srcIndexStart": "4056", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "4057", 
				"data": "// Grammar:
//   \"Start Symbol\" = <Plus>
//   <Plus> ::= '+'

// Terminal token
static assert(
	is( Token_mylang!\"+\" == Token_mylang!(SymbolType.Terminal, \"+\") )
);

// NonTerminal token
static assert(
	is( Token_mylang!\"<Plus>\" == Token_mylang!(SymbolType.NonTerminal, \"<Plus>\") )
);

// Rule token
static assert(
	is(
		Token_mylang!(\"<Plus>\", \"+\") ==
		Token_mylang!(\"<Plus>\", Token_mylang!(SymbolType.Terminal, \"+\"))
	)
);

// Or even:
static assert(
	is(
		Token_mylang!(\"<Plus>\", \"+\") ==
		Token_mylang!(\"<Plus>\", Token_mylang!\"+\"))
	)
);", 
				"srcLength": "548"
			}, 
			"2: data": {
				"srcIndexStart": "4605", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"69: data": {
			"srcIndexStart": "4608", 
			"data": "", 
			"srcLength": "1"
		}
	}
}