Why doesn't a Composition[] hold its arguments and what can be done about it?

Question

Now that Composition (also RightComposition) has shorthand syntax I am more inclined to use it, however what I feel should be one of its best advantages over the plain foo @ bar @ ## & doesn't exist: held arguments. For example I wish for the following behavior:

Composition[ToString, HoldForm][2 + 2]

(* desired output: "2 + 2" *)

I am aware that the form head[a__][b__] doesn't normally allow holding of arguments b but this has always seemed like a place an exception should have been made. Unless the first head applied has hold Attributes this would not alter behavior. Does anyone regularly make use of the evaluation of arguments that I am seeing as undesirable?

Presumptuously assuming that others find desirable the behavior that I want I see this as a sorely missed opportunity:

• the shorthand forms foo @* bar and foo /* bar could have been made to parse as LeftComposition (hypothetical) and RightComposition
• these new operators could have been made to hold arguments as I describe without breaking backwards-compatibility with Composition in past versions.

I wonder what can now be done to improve the situation.

1. I suppose it is too late to get such changes made to natively. Has such a change ever been made to Mathematica (or Wolfram Langauge) after an initial release?

2. I am tempted to try to force this behavior myself using one of the methods available. All public code except what I see as edge cases would work on my machine but my own code would fail on others.

3. Sadly it is not possible to define custom compound operators so there is no true alternative, but I could define e.g. comp[fn1, fn2] to work as I desire.

My questions therefore:

Is there some reason not to have a Composition expression hold its arguments?

Is there another option that I am failing to consider?

How can one robustly implement option #2 or #3?

Answer 1

I'm the one inside the company who suggested RightComposition (and pushed for syntax for Composition and RightComposition).

I'm sympathetic to your need, and have wanted the same thing once or twice myself. Given that not much /* and @* code has been written yet, I think it is certainly possible we could have /* parse to LeftComposition. I'm not sure what kernel shenanigans would be necessary for LeftComposition and RightComposition to hold their sub-values, however. It may simple be impossible without big changes to the evaluator, performance regressions, etc.

And even if possible, we have much higher priority kernel changes that need to be done, and of course finite resources. Some examples that happen to be fresh in my mind:

1. supporting L-value assignment for arbitrary symbols is not possible via up-values. We need this to make it possible to implemenet Dataset[...][[All, 1]] = ... and CloudSymbol["foo"][[1]] = ... in top level, without custom C code.
2. FullDefinition is currently broken in a subtle but important way, in which it can put definitions in the wrong order.
3. We also need pattern matching to work on associations (e.g. <|"A" -> _|>, which doesn't currently work).
4. We need ReplaceAll to go inside associations, which currently doesn't work.
5. Many functions still don't work on associations (e.g. RandomSample).

These are high priority problems. So I wouldn't hold your breath for any changes to /* and @*

Answer 2

Using this site as my rubber duck and attempting to answer my own questions:

(1) Reason for existing behavior

One may want to be able to do this:

heldRow = HoldForm @* Row @* List;   (* version 10 syntax *)

x = 7;

Block[{x},
  heldRow[x + x + x, x^2*x^3]
]

3 xx^5        (*  proposed behavior would yield:  x+x+xx^2 x^3  *)

My counterargument: this seems fairly uncommon and if needed it is easily accomplished with Function:

heldRow = HoldForm @ Row @ List @ ## &;

(3) Implementation

For a separate function we might use this:

comp[fns__] := Function[, Composition[fns] @@ Unevaluated /@ Hold[##], HoldAll]

This can be prettified with a formatting rule such as:

MakeBoxes[
  p : Function[, c_Composition @@ Unevaluated /@ Hold[##], HoldAll],
  _
] := InterpretationBox[RowBox[{"|", #, "|"}], p] & @ ToBoxes[c]

Now:

comp[HoldComplete, Row, List]

| HoldComplete@*Row@*List |

I am now playing with modifications to the System` functions.