anchor.diff:                          for family in children.other do
                               handle family
           res.ToArray()
  +    
  +    let checkFamilyIsGivenNonterminal nonterminalInd (family : Family) = 
  +        match leftSide with 
  +        | None -> failwith "leftSide is not specified"
  +        | Some ls -> nonterminalInd = ls.[family.prod]
  +
  +    let checkAstIsGivenNonterminal nonterminalInd (ast : AST) = 
  +        let arr = ast.map <| checkFamilyIsGivenNonterminal nonterminalInd
  +        let isAllFamiliesOfOneNonterm = 
  +            match arr.Length with
  +            | 0 -> failwith "No families in ast"
  +            | _ -> Array.forall (fun x -> x = arr.[0]) arr
  +        match isAllFamiliesOfOneNonterm with
  +        | false -> failwith "SPPF is incorrect!" 
  +        | true -> arr.[0]
  +
  +    let getNonterminalIndex nonterminal =
  +        match numToString with
  +        | None -> failwith "numToString is not specified"
  +        | Some nts ->
  +            match leftSide with 
  +            | None -> failwith "leftSide is not specified"
  +            | Some ls -> ls |> Array.tryFind (fun x -> String.Equals (nts x, nonterminal))
  +
  +    let getNonterminalIndexValue nonterminal = 
  +        match getNonterminalIndex nonterminal with 
  +        | None -> failwith <| sprintf "The grammar does not contain nonterminal %s" nonterminal
  +        | Some ind -> ind
  +
  +    let getNonterminalStringByProd prod =
  +        match numToString with
  +        | None -> failwith "numToString is not specified"
  +        | Some nts ->
  +            match leftSide with 
  +            | None -> failwith "leftSide is not specified"
  +            | Some ls -> nts <| ls.[prod]
  +
  +    new (tokens : array<'TokenType>, root : AstNode, rules : int[][]) =
  +        Tree<'TokenType>(tokens, root, rules, None, None)
   
       member this.Order = order
       member this.Root = root
  
positive.code: type ErrorDictionary<'TokenType> = Dictionary<Family, ErrorNode<'TokenType>>
  
  [<AllowNullLiteral>]
  type Tree<'TokenType> (tokens : array<'TokenType>, root : AstNode, rules : int[][]) =
      let rootFamily, isEpsilonTree =
          match root with
          | :? AST as ast -> ast, false
  
negative.code:                 | :? AST as ast -> 
                      let wanted = ast.filterFamilies isWanted
                      if wanted <> null && wanted.Count > 0
                      then Array.init wanted.Count (fun i -> getNonterminalStringByProd wanted.[i].prod)
                      else 
                          let res = new ResizeArray<_>()
                          ast.doForAllFamilies (fun x -> x.nodes.doForAll (fun y -> res.AddRange(find y)))
  