anchor.diff:      grammar
       |> grammarToGraph
       |> getStronglyConnectedComps
  -    |> List.ofSeq
  -    |> List.map (fun stronglyConnectedComponent -> List.ofSeq stronglyConnectedComponent.Vertices)
       |> handleSets
       |> defaultModules
   
  
positive.code: open Yard.Core
  open Yard.Core.IL
  open TransformAux
  
  let private grammarToGraph (grammar : Grammar<_,_>) =
  
      let handleOneRule (rule : Rule<_,_>) =
          List.map (fun nonTerm -> SEdge<Source>(rule.name, nonTerm)) <| getAllNonTermOfProd rule.body
  
      let edges = List.collect handleOneRule grammar.Head.rules
      edges.ToAdjacencyGraph<Source, SEdge<Source>>()
  
  let inline private getStronglyConnectedComps graph =
      QuickGraph.Algorithms.ConnectedComponents.StronglyConnectedComponentsAlgorithm(graph).Graphs
  
  let private approximate (grammar : Grammar<_,_>) =
      let epsilon = PSeq(List.empty, None, None)
  
negative.code:             let handleRulesOfNonterm = List.collect (fun rule -> transformOneRule rule.isStart rule.name rule.body)
  
              let changed, unchanged =
                  List.fold (fun (changedRules, unchangedRules) (nonterm : Source)->
                          let needToChange, unchanchedRules = List.partition (fun (rule : Rule<_,_>) -> rule.name = nonterm) unchangedRules
                          List.append changedRules <| handleRulesOfNonterm needToChange, unchanchedRules)
                      (changed, unchanged)
  