How to automatically interrupt `Set` with conditions

Question

Maybe this is a bad idea: I want to inject some conditions into Set associated to specfic symbols, like

clear@{f,g}
f/:Set[f[x_],y_]:=
    If[
        !IntegerQ@x,
        Print["non-integer"],
        (*pre-codes;*)
        f[x]=y;
        (*post-codes;*)
    ]

but this try fails:

Set[f[1],2]
(*
$IterationLimit::itlim: Iteration limit of 4096 exceeded.
Hold[f[1]=2]
*)

I also tried (but failed) adding some pre-codes and post-codes (like ValueQ) to escape from the infinite loop, except trivially changing Set to some other symbol like,

fSet[f[x_],y_]:=
    If[
        !IntegerQ@x,
        Print["non-integer"],
        f[x]=y;
    ]

Are there other ways to solve this problem, or should I abandon this idea?

Answer 1

There's a standard trick for dealing with this problem! It involves setting up a so-called intercept, and is a general way to avoid using the same definition you're creating within the definition:

setInterceptf = True;
Protect[setInterceptf];

f /: Set[f[x_], y_] /; setInterceptf :=
  Block[{setInterceptf = False},
    If[!IntegerQ@x, Print["non-integer"], f[x] = y]
   ]

This way, the definition applies by default (since setInterceptf is globally True)—but inside the definition, the external definition won't get used, since setInterceptf will be False.

You'll have to have an extra global symbol here, but we Protected it just in case, so it shouldn't be much of an issue.

Answer 2

Instead of f[x]=y one could try

   AppendTo[DownValues[f],HoldPattern[f[x]]:>y];

But as OP correctly points out, manual management of DownValues has disadvantages.

Answer 3

There is no need for any hocus locus here, just make the condition part of the pattern:

f /: Set[f[x_], y_] /; !IntegerQ[x] := (
    Print @ "not an integer";
    $Failed (* or nothing here and Print returns Null *)
)

It works as expected:

In[28]:= f[2] = 3

Out[28]= 3

In[29]:= f[2.2] = 5

During evaluation of In[29]:= not an integer

Out[29]= $Failed