anchor.diff:      | statement
       ;
   
  -//a normal functor expression
  -functor 
  -    : ('functor' (annotation* (type|'void'))?)? formalParameters functorBody
  +functorHeader
  +    : 'functor' (annotation* (type | 'void'))?
  +    ;
  +
  +//a functor expression that can appear as the RHS of an 
  +//assignment, in an argument list, or in parens
  +assignableFunctor 
  +    : functorHeader? formalParameters functorBody
  +    ;
  +
  +//a functor expression that can appear inside an expression
  +//or as a method argument without the need for parens
  +primaryFunctor 
  +    : functorHeader? formalParameters block
       ;
   
   //shortcut functor expression that makes the parameter list 
  -//optional
  +//optional, but can appear only using the special smalltalk
  +//style method protocol
   specialFunctor
  -    : ( (typeName | formalParameterStart) => (type|'void')? formalParameters )? functorBody
  +    : ( (formalParameterStart) => formalParameters )? functorBody
  +    ;
  +
  +//we can support enumerations as functor bodies, but
  +//I think that's just confusing to the reader
  +functorBody
  +    : ('{') => block
  +    | functorBodyExpression
  +    ;
  +
  +//special rule for syntactic predicates
  +formalParameterStart
  +    : '(' (declarationStart | ')')
  +    ;
  +
  +//special rule for syntactic predicates
  +assignableFunctorStart
  +    : 'functor' | formalParameterStart
  +    ;
  +
  +//special rule for syntactic predicates
  +primaryFunctorStart
  +    : 'functor' | '(' (declarationStart | ')' '{')
       ;
   
   //special rule for syntactic predicates
  
positive.code:     | 'extension'
      ;
  
  //special rule for syntactic predicates
  formalParameterStart
      : '(' (declarationStart | ')')
      ;
  
  //we can support enumerations as functor bodies, but
  //I think that's just confusing to the reader
  functorBody
      : ('{') => block
      | functorBodyExpression
      ;
  
  //Let's limit statements to things that make sense, like
  //Java does (we could allow any arbitrary expression if
  //we wanted to, but why?)
  
negative.code:     ;
  
  userAnnotation 
      : annotationName ( arguments | literal | reflectedBase (reflectedMember)* )?
      ;
  
  typeName
  