anchor.diff:      let internal getProd = function Product(_, p) -> p
       let private mkProd = untuple Product None
   
  -    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)
  -
       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
  
positive.code:                     Wrapper.IL.rule (mkName name uid) prod true :: rules)
                  | _ -> __unreachable__()
  
              assignProd(start, getUniqueID()) >> collectRulesFromProduct
  
          collectRules >> Wrapper.IL.grammar >> Wrapper.IL.definition
  
  
negative.code: 
  
      // --------------------------------------------- AT EVALUATE ---------------------------------------------
      let private assignProd name p =
          let getUniqueID =
              let uniqueID = ref 0
              fun (_: unit) ->
                  let last = !uniqueID
                  uniqueID := !uniqueID + 1
                  last
          Product(Some(name, getUniqueID()), getProd p)
  
  
      // --------------------------------------------- BEFORE EVALUATE ---------------------------------------------
  