anchor.diff:          let rec mkRuleWithName (name: Var) = function
               | Lambda(u, prodExpr) -> Expr.Lambda(u, mkRuleWithName name prodExpr)
               | prodExpr when prodExpr.Type = typeof<Product> ->
  -                let uname = name.Name, getUniqueID()
  -                <@@ assignProd %%(Expr.Value uname) %%(fixExpression prodExpr) @@>
  +                let assigner = assignProd name.Name
  +                <@@ assigner %%(fixExpression prodExpr) @@>
               | prodExpr -> fixExpression prodExpr // TODO: match inner grammars
           function
           | Let(name, prodExpr, body) ->
  
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:                     Wrapper.IL.rule (mkName name uid) prod true :: rules)
                  | _ -> __unreachable__()
  
              assignProd start >> collectRulesFromProduct
  
          collectRules >> Wrapper.IL.grammar >> Wrapper.IL.definition
  
  