anchor.diff:              // This is a serious thing to allow, but is required since there is no "return" in this language.
               // Without it there is no way of escaping special cases in large bits of code without indenting the main case.
               | CtxtSeqBlock _, (CtxtElse _  :: (CtxtIf _ as limitCtxt) :: _rest) 
  -                      -> (limitCtxt.StartPos,limitCtxt.StartCol)
  +                      -> PositionWithColumn (limitCtxt.StartPos,limitCtxt.StartCol)
   
               // Permitted inner-construct precise block alighnment: 
               //           interface ...
  
positive.code:             // '(match' limited by minimum of two  
              | _,(((CtxtMatch _) as ctxt1) :: CtxtSeqBlock _ :: (CtxtParen ((BEGIN | LPAREN),_) as ctxt2) :: _rest)
                        -> if ctxt1.StartCol <= ctxt2.StartCol 
                           then (ctxt1.StartPos,ctxt1.StartCol) 
                           else (ctxt2.StartPos,ctxt2.StartCol) 
  
               // 'let ... = function' limited by 'let', precisely  
               // This covers the common form 
  
negative.code:     member x.EndPos = endPos
      member x.PastEOF = pastEOF
  
  [<Struct>]
  type PositionTuple =
      val X: Position
      val Y: Position
      new (x: Position, y: Position) = { X = x; Y = y }
  
  /// Used to save the state related to a token
  [<Class>]
  type TokenTup = 
      val Token : token
      val LexbufState : LexbufState
      val LastTokenPos: PositionTuple
      new (token,state,lastTokenPos) = { Token=token; LexbufState=state; LastTokenPos=lastTokenPos }
      
      /// Returns starting position of the token
      member x.StartPos = x.LexbufState.StartPos
  