anchor.diff:      grammar
       |> grammarToGraph
       |> getStronglyConnectedComps
  -    |> List.ofSeq
  -    |> List.map (fun stronglyConnectedComponent -> List.ofSeq stronglyConnectedComponent.Vertices)
       |> handleSets
       |> defaultModules
   
  
positive.code:             let handleRulesOfNonterm = List.collect (fun rule -> transformOneRule rule.isStart rule.name rule.body)
  
              let changed, unchanged =
                  List.fold (fun (changedRules, unchangedRules) nonterm ->
                          let needToChange, unchanchedRules = List.partition (fun (rule : Rule<_,_>) -> rule.name = nonterm) unchangedRules
                          List.append changedRules <| handleRulesOfNonterm needToChange, unchanchedRules)
                      (changed, unchanged)
  
negative.code: open Yard.Core
  open Yard.Core.IL
  open TransformAux
  open QuickGraph.Algorithms
  
  let private grammarToGraph (grammar : Grammar<_,_>) =
  
      let handleOneRule (rule : Rule<_,_>) =
          List.map (fun (nonTerm : Source) -> SEdge<Source>(rule.name, nonTerm)) <| getAllNonTermOfProd rule.body
  
      let edges = List.collect handleOneRule grammar.Head.rules
      edges.ToAdjacencyGraph<Source, SEdge<Source>>()
  
  let private getStronglyConnectedComps (graph : AdjacencyGraph<Source, SEdge<Source>>) =
      let a = ConnectedComponents.StronglyConnectedComponentsAlgorithm<Source, SEdge<Source>>(graph)
      do a.Compute()
      a.Components
      |> Seq.toList
      |> List.groupBy (fun (elem : System.Collections.Generic.KeyValuePair<Source, int>) -> elem.Value)
      |> List.map (fun (_, list) -> List.map (fun (elem : System.Collections.Generic.KeyValuePair<Source, int>) -> elem.Key) list)
  
  let private approximate (grammar : Grammar<_,_>) =
      let epsilon = PSeq(List.empty, None, None)
  