# 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, but I don't know of a way to implement this series of commands as a function:

ClearAttributes[Plus, Orderless]
ClearAttributes[Times, Orderless]
e1=c (b-a)
SetAttributes[Plus, Orderless]
SetAttributes[Times, Orderless]
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

# Question

How do I define a function such that:

e1=func[c (b-a)]
e2=c (b-a) (
e1==e2


c (b – a)

(–a + b) c

True

Notes: (1) 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.

(2) This is not quite a duplicate of Changing the display ordering of orderless functions? because there the OP was looking for a function that would dictate the display order, while I was looking for a simpler approach that merely displayed the output in the same order that I typed it. [So the function would just act to protect the display order, rather than specify it.]

(3)This was originally a question that ended up having two separate parts. To make the information in this more readily searchable, I've divided this question into two (this being the first part). See: Dividing one thread into two

You could define a format that does this for you:

SetAttributes[orderlessForm, HoldFirst]

MakeBoxes[orderlessForm[expr_], form_] ^:= InternalInheritedBlock[{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.

• Thanks Carl. One problem I notice is that orderlessForm alters some functionality. E.g., e1 = orderlessForm[a + b]; e2 = orderlessForm[b + a]; e1 == e2 gives a + b == b + a instead of True. I've added an edit at the end of my question to make this requirement explicit. – theorist Dec 30 '18 at 4:20
• @theorist look at the FullForm for what you see there and then see you can add an UpValue to orderedForm to make it disappear when used in any computation like this. But in general why do you need that requirement? Why can’t you just use First first? – b3m2a1 Dec 30 '18 at 15:35
• @b3m2a1 Let me address each of your points in turn. (1): add UpValue: Sorry, I don't understand where you wish to add that or what you mean by making orderedForm disappear. (2) Need for requirement: I thought I explained that at the end of my OP—I need expressions I define when using orderlessForm will behave normally. (3) Use First first: Sorry, don't know what you mean here. – theorist Dec 30 '18 at 21:38
• @theorist you define anUpValue that handles working with Plus or you use orderlessForm only as a display form—e.g. use First to strip it before doing any operations. – b3m2a1 Dec 30 '18 at 21:45
• @b3m2a1 Sorry, still don't understand; I'd need to see the actual code. – theorist Dec 30 '18 at 21:51

I decided to contact Wolfram Technical Support (WTS) on this one. Working together, we were able to find a construction that meets my needs:

SetAttributes[fun1, HoldAll]
fun1[expr_] := Module[{}, Print[Style[HoldForm[expr], 13]]; expr];
e1 = fun1[c*(b - a)];
e2 = c*(b - a)
e1 == e2


c (b-a)

(-a + b) c

True

The HoldAll statement is necessary because, without it, MMA would sort the function's argument into canonical order before HoldForm is applied:

fun2[expr_] := Module[{}, Print[Style[HoldForm[expr], 13]]; expr];
e1 = fun2[c*(b - a)];


(-a+b) c

A comment by Mr. Wizard (see below) indicates this can also be accomplished using a pure function:

fun3 = Function[expr, Print[Style[HoldForm[expr], 13]]; expr, HoldAll];
e1 = fun3[c*(b - a)];
e2 = c*(b - a)
e1 == e2


c (b-a)

(-a + b) c

True

• "Unfortunately, you can't apply HoldAll to a pure function" Actually you can, e.g. fun2 = Function[expr, Print[Style[HoldForm[expr], 13]]; expr, HoldAll] – Mr.Wizard Jan 8 at 11:02
• @Mr.Wizard Nice! Can this also be done using the # & syntax (which I normally associate with pure functions)? – theorist Jan 8 at 20:19
• Yes, but the syntax is undocumented, and not really any cleaner than the form above. Its use is primarily in ## (SlotSequence`) which is not easy to emulate, and where scoping behavior of named parameters is a problem. See mathematica.stackexchange.com/q/29168/121 and specifically Leonid's answer for these advanced cases. – Mr.Wizard Jan 8 at 23:43