anchor.diff:      - goto controller (function)
       - flow-equation schemes 
       - initial call X0(s0)
  -
   For implementation this algorithm we need following data structures
       - W - list of calls 
       - F - dynamically generated call graph, consisting of arcs of form, X(s) -> X'(s')
       - Cashe: Call -> P(ParseStack) - dynamic array, mapping calls to sets of parse-stack segments
         (ParseStack - trees, whose nodes are ParseStack and one node is marked - bottom and another one node - top)
         **There is a unique entrym Cache[X[s]] in the cache array <==> X(s), appears in F
  -
   Definition:
   Let Σ name the states in the parser’s goto-controller
   Flow equation, Xi = Ei, denotes the function, Xi : Σ → P( Σ* )
  -
   *)
   
   module AbstractLALR
  
positive.code:                 let P = new HashSet<AbstractStack>()
                  let CalcContE = compute c p.topState E
                  for p' in CalcContE do
                      P.Add(p+p') |> ignore
                  P
  
              let CalcE1 = compute c state E1
  
negative.code: 
      
      let rec reduce state (p: AbstractStack) = 
          
          let isReadyForReduce state (p: AbstractStack)  = 
              match (actionKind (tables.action state)) = reduceFlag with
                  | true -> 
  