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 Mathematica1.

How can I achieve this?

1 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.

  • 1
    $\begingroup$ What if someone enters the 2^2 as real superscript? I guess it should be printed then as real superscript and this is the point where it becomes hard to achieve what you like. Anyway, first you can try ToString[Unevaluated[x], InputForm] but it will turn every fancy typesetting into usual code. $\endgroup$
    – halirutan
    May 18, 2015 at 0:45
  • $\begingroup$ @halirutan: thanks for the tip. It's an improvement, although it does not get rid of the Sequence[ ... ] wrapper. BTW, getting 2^2 instead of 2<sup>2</sup> is acceptable. I'll edit my question to clarify this point. $\endgroup$
    – kjo
    May 18, 2015 at 1:28
  • 1
    $\begingroup$ Related question on Stack Overflow: (12598697) $\endgroup$
    – Mr.Wizard
    Jun 25, 2015 at 10:01

2 Answers 2


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<

Let me through a first version into the room:

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

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.

  • $\begingroup$ > StringRiffle - new in 10.1? $\endgroup$
    – LLlAMnYP
    May 18, 2015 at 9:10
  • $\begingroup$ @LLlAMnYP Uhh, yes. Didn't notice that. I guess just don't even look up function names anymore. I just write what I think should exist as a function :-) $\endgroup$
    – halirutan
    May 19, 2015 at 9:36
  • $\begingroup$ The win of Mathematica is that this approach works :-D $\endgroup$
    – LLlAMnYP
    May 19, 2015 at 9:38

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.