anchor.diff:      path = null;
       String item = null;
   }
  -    : (   (nonWordSymbol["/"]) => nonWordSymbol["/"] 
  -                                  item=partialURIPath        {path = "/" + item;}
  -        | item=partialURIPath                                {path = item;}
  +    : ( SLASH item=partialURIPath        {path = "/" + item;}
  +        | item=partialURIPath            {path = item;}
         )
  -      (ref:INNER_UNIT_REF                                    {path += ref.getText();}
  +      (ref:INNER_UNIT_REF                {path += ref.getText();}
         )?
       ;
   
  
positive.code:     | LBRACE                {text = "{";}
      | RBRACE                {text = "}";}
      | COMMA                 {text = ", ";}
  //    | SEMICOLON             {text = ";";}
  //    | DOT                   {text = ".";}
      ;
  
  
negative.code:     expr = "";
      String item = null;
  }
      : (  item=qualifiableRef    {expr = expr + item + " ";}
           | item=literal           {expr = expr + item + " ";}
           | item=specialSymbol     {expr = expr + item + " ";}
           | item=expressionKeyword {expr = expr + item + " ";}
        )+
      ;
  
  /* EXPRESSIONS ARE TOO AMBIGUOUS =(
  
                  : lambdaForm
                      | caseExpression
                      | letExpression
                      | ifExpression
                      | quantification
                      | tightExpression
                      ;
  
                  private lambdaForm
                      : "fn" match
                      ;
  
                  private caseExpression
                      : "case" expression "of" match
                      ;
  
                  private letExpression
                      : "let" reclessLetBinding "in" expression
                      | "let" recLetBindingSequence "in" expression
                      ;
  
                  private ifExpression
                      : "if" expression "then" expression "else" expression
                      ;
  
                  private quantification
                      : quantifier localVariableList expression
                      ;
  
                  private tightExpression
                      : basicTightExpression
                      | annotatedExpression
                      ;
  
                  private basicTightExpression
                      : application
                      | closedExpression
                      ;
  
                  private match
                      : (VERTICALBAR)? auxMatch
                      ;
  
                  private auxMatch
                      : (nonBranchBranch VERTICALBAR) => nonBranchBranch VERTICALBAR auxMatch
                      | branch
                      ;
  
                  private nonBranchBranch
                      : pattern ARROW nonBranchExpression
                      ;
  
                  private branch
                      : pattern ARROW expression
                      ;
  
                  private nonBranchExpression
                      : tightExpression
                      ;
  
                  private reclessLetBinding
                      : pattern EQUALS expression
                      ;
  
                  private recLetBindingSequence
                      : (recLetBinding)*
                      ;
  
                  private recLetBinding
                      : "def" name (formalParameterSequence)? (COLON sort)? EQUALS expression
                      ;
  
                  private formalParameterSequence
                      : ((closedPattern)*)?
                      ;
  
                  private quantifier
                      : "fa"
                      | "ex"
                      ;
  
                  private localVariableList
                      : LPAREN
                        annotatedVariable
                        (COMMA annotatedVariable
                        )*
                        RPAREN
                      ;
  
                  private annotatedVariable
                      : nonKeywordName
                        (COLON sort
                        )?
                      ;
  
                  private closedExpression
                      : unqualifiedOpRef
                      | selectableExpression
                      ;
  
                  private application
                      : closedExpression
                        (closedExpression  // syntactic predicate to take care of cases like "case l of Nil -> true | _ -> false"
                        )*
                      ;
  
                  private annotatedExpression
                      : basicTightExpression (tightExpression)? COLON sort
                      ;
  
                  private unqualifiedOpRef
                      : name
                      ;
  
                  private selectableExpression
                      : basicSelectableExpression
                      | fieldSelection
                      ;
  
                  // TODO: This could probably be optimized a lot by left-factoring
                  private basicSelectableExpression
                      : twoNameExpression
                      | natFieldSelection
                      | literal
                      | (tupleDisplay) => tupleDisplay
                      | (sequentialExpression) => sequentialExpression
                      | parenthesizedExpression
                      | listDisplay
                      | structor
                      | recordDisplay
                      | monadExpression
                      ;
  
                  private twoNameExpression
                      : name DOT name
                      ;
  
                  private natFieldSelection
                      : unqualifiedOpRef DOT natSelector
                      ;
  
                  private natSelector
                      : NAT_LITERAL
                      ;
  
                  private fieldSelection
                      : basicSelectableExpression 
                        (selectableExpression
                        )*
                        DOT fieldSelector
                      ;
  
                  private fieldSelector
                      : NAT_LITERAL
                      | name
                      ;
  
                  private tupleDisplay
                      : LPAREN
                        (tupleDisplayBody
                        )?
                        RPAREN
                      ;
  
                  private tupleDisplayBody
                      : expression COMMA expression
                        (COMMA
                         expression
                        )*
                      ;
  
                  private recordDisplay
                      : LBRACE
                        (recordDisplayBody
                        )?
                        RBRACE
                      ;
  
                  private recordDisplayBody
                      : fieldFiller
                        (COMMA
                         fieldFiller
                        )*
                      ;
  
                  private fieldFiller
                      : name EQUALS expression
                      ;
  
                  private sequentialExpression
                      : LPAREN
                        openSequentialExpression
                        RPAREN
                      ;
  
                  private openSequentialExpression
                      : expression (SEMICOLON expression)+
                      ;
  
                  private voidExpression
                      : expression
                      ;
                  
                  private listDisplay
                      : LBRACKET
                        (listDisplayBody
                        )?
                        RBRACKET
                      ;
  
                  private listDisplayBody
                      : (expression
                         (COMMA expression
                         )*
                        )?
                      ;
  
                  private structor
                      : projector
                      | relaxator
                      | restrictor
                      | quotienter
                      | chooser
                      | embedder
                      | embeddingTest
                      ;
  
                  private projector
                      : "project" fieldSelector
                      ;
  
                  private relaxator
                      : "relax" closedExpression
                      ;
  
                  private restrictor
                      : "restrict" closedExpression
                      ;
  
                  private quotienter
                      : "quotient" closedExpression
                      ;
  
                  private chooser
                      : "choose" closedExpression
                      ;
  
                  private embedder
                      : "embed" name
                      ;
  
                  private embeddingTest
                      : "embed?" name
                      ;
  
                  private parenthesizedExpression
                      : LPAREN
                        expression
                        RPAREN
                      ;
  
                  private monadExpression
                      : monadTermExpression
                      | monadBindingExpression
                      ;
  
                  private monadTermExpression
                      : LBRACE
                        expression SEMICOLON monadStmtList
                        RBRACE
                      ;
  
                  private monadStmtList
                      : expression
                      | expression SEMICOLON monadStmtList
                      | pattern BACKWARDSARROW expression SEMICOLON monadStmtList
                      ;
  
                  private monadBindingExpression
                      : LBRACE
                        pattern BACKWARDSARROW expression SEMICOLON monadStmtList
                        RBRACE
                      ;
  
                  private relaxPattern
                      : "relax" closedExpression tightPattern
                      ;
  
  END OF EXPRESSION STUFF*/
  
  //---------------------------------------------------------------------------
  private specialSymbol returns[String text]
  