Replacing with pattern on built-in symbols?

Question

I have:

f[a, b] /. f[x__] -> g[x, 0] // InputForm
(* Out: g[a, b, 0] *)

Which is what I expect, but when I use a built in symbol instead of f, the result is different, for example:

Times[a, b] /. Times[x__] -> g[x, 0] // InputForm
(* Out: g[a*b, 0] *)

How could I replace the multiplication in this case to get the same result as above?

Answer 1

Amplifying my comment. The issue you are encountering is that a single argument Times evaluates (it has nothing to do with the Flat attribute of Times):

Times[x__]

x__

Hence, your code is actually doing:

Times[a, b] /. x__ -> g[x, 0]

g[a b, 0]

The way to avoid this is to prevent evaluation of the LHS pattern, with the typical methods being to use Verbatim:

Times[a, b] /. Verbatim[Times][x__] -> g[x, 0]

g[a, b, 0]

or to use HoldPattern:

Times[a, b] /. HoldPattern[Times[x__]] -> g[x, 0]

g[a, b, 0]

Answer 2

The problem is not that Times is a built-in symbol. As explained in another answer it stems from the evaluation of the Times in the LHS of the rule. My previous explanation (see edit) was wrong and misleading.

Having said that, one way to make it work is to simply replace the Head

In[1]:= a b /. Times -> (g[##, 0] &)

Out[1]:= g[a, b, 0]

If you have more complicated replacement rules you can always replace Times with a new symbol e.g. newTimes, make it Orderless if needed and then apply the rules to newTimes.