anchor.diff:  
   type Processor<'TokenType,'br, 'range, 'node>  when 'br:equality and  'range:equality and 'node:null
       (
  -        tokenize: Appr<'br> -> ParserInputGraph<'TokenType>
  +        //tokenize: Appr<'br> -> ParserInputGraph<'TokenType>
  +        tokenize: Appr<'br> -> Test<ParserInputGraph<'TokenType>, array<Smbl<char * Position<'br>>>>
           , parse, translate, tokenToNumber: 'TokenType -> int, numToString: int -> string, tokenData: 'TokenType -> obj, tokenToTreeNode, lang, calculatePos:_->seq<'range>
           , getDocumentRange:'br -> 'range
           , printAst: Tree<'TokenType> -> string -> unit
  
positive.code:         let lexerErrors = new ResizeArray<_>()
  
          let addError tok =
              let e tokName lang (grToken: GraphTokenValue<'br>) = 
                  grToken |> calculatePos
                  |> Seq.iter
                      (fun br -> parserErrors.Add <| ((sprintf "%A(%A)" tokName lang), br))
              let name = tok |> (tokenToNumber >>  numToString)
              let (language : string), br = tokenData tok :?> _
              e name language br
          
          
          processLang graph lexerErrors.Add addError
  
negative.code:             lexingFinished.Trigger(new LexingFinishedArgs<'node>(tokensList, lang))
  
      let processLang graph addLError addPError =
  //        let tokenize g =
  //            try 
  //                tokenize g
  //                |> Some 
  //            with
  //            | LexerError(t,grToken) ->
  //                (t, (grToken :?> GraphTokenValue<'br>).Edges |> Seq.nth 0 |> fun e -> e.BackRef |> getDocumentRange)
  //                |> addLError
  //                None
  //        
  //        let tokenizedGraph = tokenize graph         
      
          let tokenizedGraph = 
              match tokenize graph with
              | Success res -> res |> Some
              | Error errors -> 
                  errors |> Array.map (function Smbl e -> fst e |> string, (e |> snd).back_ref |> getDocumentRange | e -> failwithf "Unexpected tocenization result: %A" e)
                  |> Array.iter addLError 
                  None
  
          prepareToHighlighting tokenizedGraph tokenToTreeNode 
  
          tokenizedGraph 
          |> Option.map
              (fun x -> 
                  let y = parse x
                  printfn "Tree: %A" y
                  y)
          |> Option.iter
              (function 
                  | Yard.Generators.RNGLR.Parser.Success(tree, _, errors) ->
  