Concatenated rule applications (applying rules to rules correctly)

Question

I am trying to apply a series of individual rules onto an expression sequentially, but also not have to write out the repeated ReplaceAll functions each time I want to perform the same series of rules.

Here's an illustrative example of my problem:

(* r1, r2 and r3 are the individual rule transformations *)
r1[a_] := {a :> 3 a};
r2[a_] := {a :> -a};
r3[a_] := {a :> a + 1};

(* Try to define a single rule operator which applies rules in a given order *)
rall[a_] := r1[a] /. r2[a] /. r3[a];

(* Ideal answer is given by *)
a /. r1[a] /. r2[a] /. r3[a]

Which evaluates to -3(a+1), applying each rule sequentially, whereas

a /. rall[a]

evaluates to a, having not applied any of the rules. This can be understood, since rall[a] evaluates to {-a-1:>3(-(a+1))}, having applied the rules r2[a] and r3[a] to the initial r1[a] term, not just the rhs instances of a in the rules expressions.

How can I build a composite rule function that achieves my aim? Is there a way to delay the evaluation of the rules stated in rall[a] until I apply it to a variable?

Answer 1

Maybe with the help of Fold or FoldList :

See what happens here:

FoldList[#1 /. #2 &, a, {r1[a], r2[a], r3[a]}]

{a, 3 a, -3 a, -3 (1 + a)}

Replace FoldList with Fold to get directly the last result.

In other words:

rall[a_] := Fold[#1 /. #2 &, a, {r1[a], r2[a], r3[a]}]

then

rall[a]

-3 (1 + a)