anchor.diff:          generationState
   
       let getForestWithToken range = 
  -        let res = new ResizeArray<'node>()
  -        for ast, errors in forest do
  -            let trees = ast.GetForestWithToken range <| (this.TokenToPos calculatePos)
  -            for tree in trees do
  -                let treeNode = (this.TranslateToTreeNode tree errors)
  -                res.Add treeNode
  -        res
  +
  +        forest
  +        |> List.map
  +            (
  +                fun (ast, errors) -> 
  +                    let trees = ast.GetForestWithToken range <| this.TokenToPos calculatePos
  +                    trees
  +                    |> List.map (fun tree -> this.TranslateToTreeNode tree errors)
  +            )
  +        |> List.concat
  +        |> ResizeArray.ofList
   
       member this.GetNextTree index =         
           let state = getNextTree 0//index
  
positive.code:                         //cfg.PrintToDot "result cfg.dot"
                          let semErrors = cfg.FindUndefVariable()
                          semErrors |> List.iter addSError
  
                  | Yard.Generators.ARNGLR.Parser.Error(_, tok, _) -> 
                      if tok <> Unchecked.defaultof<'TokenType>
                      then tok |> addPError 
              )
  
      let getNextTree index : TreeGenerationState<'node> = 
          if forest.Length <= index
          then
              generationState <- End(null)
          else
              let mutable curSppf, errors = List.nth forest index
              let unprocessed : Terminal list = 
                  match generationState with
                  | Start ->   Array.init curSppf.TokensCount (fun i -> new Terminal(i)) |> List.ofArray
                  | InProgress (_, unproc) -> unproc |> List.map (fun n -> n :?> Terminal) 
                  | _ -> failwith "Unexpected state in treeGeneration"
                  
  
negative.code:             treeNode, true
          | _ -> failwith "Unexpected state in tree generation"
  
      member this.TokenToPos calculatePos (token : 'TokenType) = 
          let data (*: FSA<char*Position<'br>>*) = unbox <| tokenData token
          calculatePos data
  
      member this.GetForestWithToken range = getForestWithToken range
  
      member this.GetPairedRanges leftNumber rightNumber range toRight = 
          
          let tokToPos = this.TokenToPos calculatePos
          
          otherForest
          |> List.map (fun otherTree -> otherTree.FindAllPair leftNumber rightNumber range toRight tokenToNumber tokToPos)
          |> List.map 
              (
                  fun token -> 
                      token 
                      |> ResizeArray.map(fun token -> tokToPos token)
                      |> Seq.concat
              )
          |> Seq.concat
          |> ResizeArray.ofSeq
  
  
      member this.TranslateToTreeNode nextTree errors = (Seq.head <| translate nextTree errors)
      
  