anchor.diff:                      Wrapper.IL.rule (mkName name uid) prod true :: rules)
                   | _ -> __unreachable__()
   
  -            assignProd(start, getUniqueID()) >> collectRulesFromProduct
  +            assignProd start >> collectRulesFromProduct
   
           collectRules >> Wrapper.IL.grammar >> Wrapper.IL.definition
   
  
positive.code: 
  
      // --------------------------------------------- AT EVALUATE ---------------------------------------------
      let private getUniqueID =
          let uniqueID = ref 0
          fun (_: unit) ->
              let last = !uniqueID
              uniqueID := !uniqueID + 1
              last
  
      let inline private assignProd uname p = Product(Some uname, getProd p)
  
  
      // --------------------------------------------- BEFORE EVALUATE ---------------------------------------------
  
negative.code:     let internal getProd = function Product(_, p) -> p
      let private mkProd = untuple Product None
  
      let private applyBinop op a b = mkProd <| op (getProd a) (getProd b)
      let private applyUnaryop op = getProd >> op >> mkProd
  
      type Product with
          static member (%) (p, (m, n)) = Production.PRepet(getProd p, Some m, Some n)
          static member (%) (p, (m)) = Production.PRepet(getProd p, Some m, None)
          static member (+) (a: Product, b: Product) = applyBinop Wrapper.IL.conc a b
  
      let (<|>) = applyBinop <| untuple Production.PAlt
  