anchor.diff:      let Conv (e:#Expr, eraseEquality) =
           let e = optimize e
   
  -        let linqExpr = ConvExpr { eraseEquality = eraseEquality; varEnv = Map.empty; letrec = None } e
  +        let linqExpr = ConvExpr { eraseEquality = eraseEquality; varEnv = Map.empty } e
   
           Expression.Lambda(linqExpr, Expression.Parameter(typeof<unit>)) |> asExpression
   
  
positive.code:             Expression.Block(e1P, e2P) |> asExpr
  
          | Patterns.Let (v,e,b) -> 
              let env =
                  match env.letrec with
                  | None -> env
                  | _ -> { env with letrec = None }
  
              let vP = Expression.Variable (v.Type, v.Name)
              let eP = ConvExpr env e
              let assign = Expression.Assign (vP, eP) |> asExpression
  
negative.code:             let vePs =
                  vPs
                  |> List.map (fun (v, vP, e) ->
                      let funcObject, assignToConstruction, assignState = 
                          match LetRecConvExpr env (Some v) e with
                          | AsLetRecExpression (funcObject, assignToFuncObject, assignState) -> funcObject, assignToFuncObject, assignState
                          | _ -> failwith "Logic error"
                      vP, funcObject, assignToConstruction, assignState)
  