How to print unevaluated arguments in the form they were originally typed in?

Question

I'm looking for a way to print a function's arguments, not only unevaluated, but also in the way they were originally typed in.

By way of experimentation, I tried stuff like this:

echo[x___] := ToString[Unevaluated[x]];
SetAttributes[echo, HoldAll];

...but nothing quite worked. For example, with the above function, the expression

Print[TemplateApply[">``<", echo[2^2, "foo", 2 + 2, None]]]

outputs this to the screen:

>          2
Sequence[2 , foo, 2 + 2, None]<

Instead, I want the output to be this:

>2^2, "foo", 2 + 2, None<

IOW, I want the output of echo to be a string that more closely represents the arguments as they were typed in to Mathematica¹.

How can I achieve this?

---

_{¹ The amount of whitespace between the arguments, however, is not too important. E.g., either 1 ,2,3 or
1, 2, 3 would be OK as the value of echo[1 ,2,3]. Similarly, preserving fancy typesetting is of secondary importance. The example above shows some of the deviations from perfect faithfulness that I'm most trying to avoid: the Sequence[...] wrapper, the added second line to accommodate the superscript, and the omission of the double-quotes around strings.}

Answer 1

I know I have answered a very similar question before but I can't find it now. Of what I can find my own question How can I get the unchanged Box form of an arbitrary expression? is probably closest, though more recently Why aren't parentheses ( ) an expression in Mathematica? maybe closer in application to what you need. For pursuing your goal it is important to understand how Mathematica input works. Please refer to the Sidebar: Box form manipulation section of my answer in the second linked Q&A for a foundation.

Since the Box form is lost by the time your echo function is evaluated you cannot achieve complete transcription by normal means. However you can use a Box-level preprocessing to handle things in a nonstandard way.

p0 = RowBox[{arg___}] | arg_;

$PreRead = # /. 
    RowBox[{"echo", "[", p0, "]"}] |
    RowBox[{"echo", "@", p0}] | 
    RowBox[{p0, "//", "echo"}] :> 
       RowBox[{"echo", "[",
           With[{x = Unique[]}, x = {arg}; ToString@Unevaluated@x],
       "]"}] &;

With this definition in place Front End uses of echo now spit out their raw Box content wrapped in a List:

echo[1*^99, 2^2]

echo[{"1*^99", ",", RowBox[{"2", "^", "2"}]}]

Note that no amount of HoldComplete type measures will preserve the same. From here you could process the Box data as necessary but beware that it can get hairy quickly.

Your revised requirements seem less stringent than this after all so a less severe approach may be in order. Perhaps you simply want to avoid the multi-line formatting of OutputForm and the appearance of "Sequence" in the result and this may do:

$PreRead = .   (* clear earlier definition *)

echo[args___] := ToString[Unevaluated @ {args}, InputForm] ~StringTake~ {2, -2}

Print[TemplateApply[">``<", echo[2^2, "foo", 2 + 2, None]]]

>2^2, "foo", 2 + 2, None<

Answer 2

Let me through a first version into the room:

SetAttributes[echo, HoldAll];
echo[x___] := StringRiffle[{##}, ", "] & @@ 
   Function[arg, ToString[Unevaluated[arg], InputForm], {HoldFirst}] /@
   Hold[x];

Now you get

Print[TemplateApply[">``<", echo[2^2, "foo", 2 + 2, None]]]

(* >2^2, "foo", 2 + 2, None< *)

Be aware that you might need HoldAllComplete and HoldComplete if you want

echo[Sequence[1, 2, 3]]

really return Sequence[1,2,3] as one argument. The same is true for Unevaluated arguments.