I believe this happens because Unevaluated
(along with some other special constructs such as Evaluate
and Sequence
) should not be thought of as evaluating in a certain way. What they actually do is influence how their enclosing expression is evaluated. More precisely, they influence how their enclosing expression will treat its arguments.
An example:
Assume f
has the HoldFirst
attribute and we enter:
f[Evaluate[1+1], 2+2, Unevaluated[3+3]]
The following happens:
- Mathematica scans the expression starting from the outermost level. It first looks at
f
, and decides what to do with each of its arguments: should they be evaluated or not?
- Once this decision is made, the arguments marked for evaluation will be evaluated. The ones marked to be held are left as they are.
- Finally,
f
itself is evaluated.
- If
f
did not itself need to be evaluated, the Unevaluated
wrapped is restored.
Wrappers like Evaluate
and Unevaluated
are handled in step 1. and not in step 2. Their effect is applied in step 1 and they are immediately removed, before proceeding to step 2.
Thus, Mathematica first looks at f
's first argument: Since f
is HoldFirst
, it would not normally be marked for evaluation. But it sees Evaluated
. Evaluated
is now stripped and its contents are marked for evaluation. Now it looks at the second argument, 2+2
. It decides that this will need evaluation. Finally, it looks at the third argument: Unevaluated
is stripped, and its contents are marked to be left alone. So the decision is
- 1st argument: evaluate
- 2nd argument: evaluate
- 3rd argument: don't evaluate
Now the evaluation happens: 1+1 -> 2, 2+2 -> 4, 3+3 -> 3+3 (left alone)
Finally, f
itself is evaluated with these results.
Example:
SetAttributes[f, HoldFirst]
f[Evaluate[1 + 1], 2 + 2, Unevaluated[3 + 3]]
(* f[2, 4, Unevaluated[3 + 3]] *)
Notice that Unevaluated
was restored, as no evaluation needed to be done for f
itself. If f
had a definition, as below, the Unevaluated
would not be restored:
f[args___] := Hold[args]
f[1 + 1, 2 + 2, 3 + 3]
(* Hold[1 + 1, 4, 6] *)
Thus, Print[Unevaluated[1+2]]
works like this:
- Strip the
Unevaluated
and mark 1+2
to be left alone
1+2
is marked as held, so no evaluation necessary
Print
prints the expression it received: 1+2
Print[ToExpression["Unevaluated[1+2]"]]
works like this:
- The argument of
Print
is marked for evaluation
ToExpression["Unevaluated[1+2]"]
is evaluated and results in Unevaluated[1+2]
Print
prints the expression it received: Unevaluated[1+2]
The explanation here omits several steps. To see the entire evaluation procedure, take a look at "Mathematica Internals" by David Withoff.

Head
and give the result1+2
in the above example. $\endgroup$