I am facing an issue when I try to reverse the arguments of a function in a replacement rule.
Let me give an example :
g[x3, x2, x1] /. {g[arg___] -> g[Sequence @@ Reverse[{arg}]]}
This outputs
g[x3,x2,x1]
Even using the built-in function
g[x3, x2, x1] /. {g[arg___] -> ReverseApplied[g][arg]}
gives the same incorrect output.
What is happening here and what is the correct way of doing this ?
expr = g[x3, x2, x1];
You must use RuleDelayed (:>) instead of Rule
expr /. g[arg___] :> g[Sequence @@ Reverse[{arg}]]
g[x1, x2, x3]
Many other possibilities include
Cases with {0} level
First @ Cases[expr, h_[args__] :> h[Reverse[{args}]], {0}]
g[{x1, x2, x3}]
Position and Part or Query
p = Reverse @ Flatten @ Position[expr, _Symbol, Heads -> False]
{3, 2, 1}
expr[[p]]
g[x1, x2, x3]
Query[p] @ expr
g[x1, x2, x3]
The Rule versus RuleDelayed issue probably warrants closing this question. That is a basic distinction easily discoverable in the documentation and books and examples etc. However, there are nuances here that it might be worth discussing.
If you do this
g[x3, x2, x1] /. {g[arg___] :> ReverseApplied[g][arg]}
you need to be aware that the g expressions will be evaluated. To demonstrate, let's give g a definition:
g[a_, b_, c_] := h[a, b]
Now evaluate
g[x3, x2, x1] /. {g[arg___] :> ReverseApplied[g][arg]}
(* h[x3, x2] *)
Presumably, what we wanted to get was h[x1, x2]. So, to answer your question of "what is the correct way of doing this?", you should do what you already knew how to do: use ReverseApplied, but do it directly.
ReverseApplied[g][x3, x2, x1]
(* h[x1, x2] *)
There is no need to go through the whole replacement exercise, just apply ReverseApplied directly.
Now, if the expression g[x3, x2, x1] does not evaluate to something other than itself, then the suggested replacements based on RuleDelayed will work, but the simpler way to do it would be to simply apply Reverse:
(* I'll use gg to distinguish from the previous case *)
Reverse@gg[x3, x2, x1]
(* gg[x1, x2, x3] *)
A situation where this might make sense is if the arguments have distinct types that define a correct order. For example, let's define gg like this:
gg[a_Integer, b_String] := StringRepeat[b, a]
In the expected case we have
gg[3, "abc"]
(* "abcabcabc" *)
But maybe we somehow have gg["abc", 3] that we want to evaluate in the "obvious" way. Then we can just do
Reverse[gg["abc", 3]]
(* "abcabcabc" *)
Or, of course, we can still use the more general
ReverseApplied[gg]["abc", 3]
(* "abcabcabc" *)
which avoids having to consider whether the gg["abc", 3] expression will evaluate or not.
Another way to do this is as follows:
f = Apply @@ {Head@#, Reverse@*List @@ #} &;
f@g[x3, x2, x1]
g[x1, x2, x3]
