anchor.diff:                          elements |> List.collect
                               (fun elem ->
                                   match elem.rule with
  -                                |PRef(t, _) when not (isEps (fst t)).IsEmpty -> 
  +                                |PRef(t, _) when fst t |> isEps |> List.isEmpty |> not-> 
                                       incr i
                                       [{
                                           omit = elem.omit
  
positive.code:                             (match rule.body with PSeq(e, a, l) -> a | x -> None),
                              (match rule.body with PSeq(e, a, l) -> l | x -> None))
                  |x -> rule.body
              let addRule (numberRule: Rule.t<_, _>) (eps: int list) = 
                  [{
                      name=numberRule.name
                      args=numberRule.args
                      _public=numberRule._public
                      metaArgs=numberRule.metaArgs
                      body=PSeq(
                                  (match numberRule.body with PSeq(e, a, l) -> e | x -> []) |> List.collect 
                                      (fun elem ->
                                          match elem.rule with
                                          |PRef(t, _) when 
                                              eps 
                                              |> List.map (fun e -> e.ToString()) 
                                              |> List.exists (fun e -> (e = (fst t))) -> []
                                          |PRef(t, _) when 
                                              not (
                                                  eps 
  
negative.code:     //--Функция для проверки вхождения эпсилон-правила---------------------------------------------
  
      let isEps s = 
          epsList |> List.collect (fun eps -> if s = eps then [eps] else [])
      
      //--Список эпсилон-правил входящих в данное правило--------------------------------------------     
  
  