anchor.diff:  
   private fieldPattern
       : name
  -      (nonWordSymbol["="]
  +      (EQUALS
          pattern
         )?
       ;
   
   private quotientPattern
  -    : "quotient"
  -      closedExpression
  -      tightPattern
  -    ;
  -
  -//TODO: selectableExpression
  +    : "quotient" closedExpression tightPattern
  +    ;
  +
  +// expressions ---------------------------------------------------------------------------
  +private expression returns[String expr]
  +{
  +    expr = "";
  +    String item = null;
  +}
  +    : 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
       ;
         
  -
  -/* THIS IS BAD BECAUSE OF TOO MUCH NON-DETERMINISM...LOTS OF POTENTIAL FOR "INFINITE LOOPS"
  -private pattern[List patternList]
  -    : basePattern[patternList]
  -    | annotatedPattern[patternList]
  -    ;
  -
  -private basePattern[List patternList]
  -    : parenPattern[patternList]
  -    | bracePattern[patternList]
  -    | bracketPattern[patternList]
  -    | plainPattern[patternList]
  -    ;
  -
  -private annotatedPattern[List patternList]
  -{
  -    String ignore = null;
  -}
  -    : basePattern[patternList]
  -      nonWordSymbol[":"]
  -      //TODO - fix sort to match grammar: sort
  -      ignore=sort
  -    ;
  -      
  -private parenPattern[List patternList]
  -    : LPAREN 
  -      (
  -       | (pattern[patternList]
  -         )*
  -      )
  +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 bracePattern[List patternList]
  +private tupleDisplayBody
  +    : expression COMMA expression
  +      (COMMA
  +       expression
  +      )*
  +    ;
  +
  +private recordDisplay
       : LBRACE
  -      (pattern[patternList]
  +      (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 bracketPattern[List patternList]
  -    : LBRACKET
  -      ( 
  -       | (pattern[patternList]
  -         )*
  -      )
  -      RBRACKET
  -    ;
  -
  -private plainPattern[List patternList]
  -    : (patternJunk[patternList]
  -      )*
  -    ;
  -
  -private patternJunk[List patternList]
  -    : literal
  -    | expressionKeyword
  -    | idName
  -    | qualifiableRef
  -    | equals
  -    | COMMA
  -    | nonWordSymbol["::"]
  -    | nonWordSymbol["|"]
  -    | nonWordSymbol[":"]
  -    | nonWordSymbol["->"]
  -    | "quotient"
  -    | nonWordSymbol["."]
  -    ;
  -*/
  +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
  +    ;
  +
  +
   //---------------------------------------------------------------------------
   private specialSymbol returns[String text]
   {
  
positive.code:     : (closedPattern
        )*                    {params = (String[]) paramList.toArray(new String[]{});}
      ;
  
  private pattern
      : basicPattern
  
negative.code:       name=qualifiableOpNames
        (fixity
        )?
        COLON
        sort=sortScheme
                              {op = builder.createOp(name, sort);
                               ParserUtil.setBounds(builder, op, begin, LT(0));
                              }
  