Background

For display purposes, I sometimes find it desirable to defeat Mathematica's canonical ordering of variables, and instead have it output terms in the order in which I type them. E.g., instead of this:

b-a

v=v0+a t

a8+a9+a10

–a + b

a t + v0

a10 + a8 + a9

...I'd prefer this:

b – a

v0 + a t

a8 + a9 + a10

This can be easily accomplished by removing the Orderless attributes from Plus and Times, entering the expression, and then immediately restoring those attributes (it is important to do the latter, since their absence alters basic functionality; e.g., without Orderless, Plus doesn't recognize that a + b is mathematically identical to b + a).

ClearAttributes[Plus, Orderless]

ClearAttributes[Times, Orderless]

e1=c (b-a)

SetAttributes[Plus, Orderless]

SetAttributes[Times, Orderless]

c (b – a)

Question

How do I implement the above as a function? I.e., I'd like to define a function such that:

e1=func[c (b-a)]

e2=c (b-a) (*confirm that Orderless is restored to both Plus and Times*)

e1==e2 (*check that functionality isn't affected by how function is displayed; want output to be "True"*)

c (b – a)

(–a + b) c

True

EDIT: Note that I want to alter only the display format, not any other functionality. E.g., MMA should still recognize that e1 and e2 are mathematically equivalent, even though e1 was defined while the Orderless Attribute was absent from both Plus and Times.

Thus far I've only managed the following, which achieves the desired output, but requires I enter a function, then the expression, then another function:

func1 := (ClearAttributes[Plus, Orderless]; ClearAttributes[Times, Orderless]) &;

func2 := (SetAttributes[Plus, Orderless]; SetAttributes[Times, Orderless]) &;

func1[_]

e1=c (b-a)

func2[_]

e2=c (b-a)

e1==e2

c (b – a)

(–a + b) c

True

So how do I combine the above into a single function that takes the expression as its argument? Or, to put it another way, how do I turn the following pseudocode into working MMA syntax?:

func := (ClearAttributes[Plus, Orderless]; 

ClearAttributes[Times, Orderless]; #; 

SetAttributes[Plus, Orderless]; 

SetAttributes[Times, Orderless]) &;

func[c (b-a)]

(no output)

The above function gives no output because pure functions, by default, only return the result of the last statement. I could get output by moving # to the end, as follows, but that just causes it to return the argument with standard canonical ordering, since here # is evaluated after the Orderless Attributes are restored:

func := (ClearAttributes[Plus, Orderless]; 

ClearAttributes[Times, Orderless]; 

SetAttributes[Plus, Orderless]; 

SetAttributes[Times, Orderless];#) &;

func[c (b-a)] 

(-a+b) c

Granted, one workaround might be to use a DownValues construction for the last statement, since that could step backwards and get # in its earlier (non-canonical) format, and output it. But it would be much more straightforward if I could just tell the function to output whatever intermediate result I wished.

Finally, if I abandon pure functions, I could do this, but it doesn't fully work because the output of Print is Null:

SetAttributes[f, HoldAll]

f[expr_] := 

Module[{}, ClearAttributes[Plus, Orderless]; 

ClearAttributes[Times, Orderless];

Print[expr];

SetAttributes[Plus, Orderless]; SetAttributes[Times, Orderless]]

e1 = f[c (b - a)]

e2 = c (b - a)

e1 == e2

c (b-a)

(-a + b) c

Null == (-a + b) c

So it would be nice if there were a simple way to get a function (both pure and otherwise) comprising a compound expression to return an assignable non-Null intermediate result (without exiting, which is what Return would do), which is something I could apply to other problems as well. I.e., I sometimes need MMA to 'do X, then do Y and return the result, then do Z', so seeing how it's done for this application would serve as a template that I could use elsewhere. I found this thread: Compound Statements and returning earlier results in () parentheses, but wasn't able to apply it to my problem.

You could define a format that does this for you:

SetAttributes[orderlessForm, HoldFirst]



MakeBoxes[orderlessForm[expr_], form_] ^:= Internal`InheritedBlock[{Times, Plus},

    ClearAttributes[{Times, Plus}, Orderless];

    MakeBoxes[expr, form]

]

Then:

orderlessForm[c (b - a)]

c (b - a)

And, the usual output when not using the wrapper:

c (b - a)

(-a + b) c

Note that the HoldFirst attribute does most of the work.