# Impossible to bypass evaluation on returned values?

Following all the great advice on this other question, I'm now fluent with HoldAllComplete and Unevaluated on the input side of quote-type functions. I continued my investigations and produced the following attempt at a generic conversion from expression to captive (or quoted) expression:

ClearAll[captive];
SetAttributes[captive, HoldAllComplete];
captive[expr_ /; AtomQ @ Unevaluated @ expr] := expr
{captive @ head} ~Join~ (captive /@ (Unevaluated @ {args}))
captive[x___] := Throw[{x}];


This is really great and handles almost all my scenarios. To wit, the following abbreviated test set produces the desired results

testSet = {"foo", foo, 12, 0, 3/4, 3.14, 2.72 + 3.14 I,
Infinity, {1, 2, 3}, {1, "a", b}, f, f[b], f[1, "a", b], f[{}],
f[{1, "a", b}], f[a][b], f[a][1, "a", b], f[a][{}],
f[a][{1, "a", b}], Hold[Plus @@ {}], Hold[Plus @@ {1, 2, 3}],
Plus @@ {1, "a", b}, 1 + "a" b, a + b*c};


as we can see in the output of

MapThread[List, {
InputForm /@ testSet,
InputForm /@ captive /@ testSet}] // TraditionalForm


(input on left, output on right)

$\left( \begin{array}{cc} \text{foo} & \text{foo} \\ \text{foo} & \text{foo} \\ 12 & 12 \\ 0 & 0 \\ 3/4 & 3/4 \\ 3.14 & 3.14 \\ 2.72 + 3.14*I & 2.72 + 3.14*I \\ \text{Infinity} & \{\text{DirectedInfinity}, 1\} \\ \{1, 2, 3\} & \{\text{List}, 1, 2, 3\} \\ \{1, \text{a}, b\} & \{\text{List}, 1, \text{a}, b\} \\ f & f \\ f[b] & \{f, b\} \\ f[1, \text{a}, b] & \{f, 1, \text{a}, b\} \\ f[\{\}] & \{f, \{\text{List}\}\} \\ f[\{1, \text{a}, b\}] & \{f, \{\text{List}, 1, \text{a}, b\}\} \\ f[a][b] & \{\{f, a\}, b\} \\ f[a][1, \text{a}, b] & \{\{f, a\}, 1, \text{a}, b\} \\ f[a][\{\}] & \{\{f, a\}, \{\text{List}\}\} \\ f[a][\{1, \text{a}, b\}] & \{\{f, a\}, \{\text{List}, 1, \text{a}, b\}\} \\ \text{Hold}[\text{Plus} \text{@@} \{\}] & \{\text{Hold}, \{\text{Apply}, \text{Plus}, \{\text{List}\}\}\} \\ \text{Hold}[\text{Plus} \text{@@} \{1, 2, 3\}] & \{\text{Hold}, \{\text{Apply}, \text{Plus}, \{\text{List}, 1, 2, 3\}\}\} \\ 1 + \text{a} + b & \{\text{Plus}, 1, \text{a}, b\} \\ 1 + \text{a}*b & \{\text{Plus}, 1, \{\text{Times}, \text{a}, b\}\} \\ a + b*c & \{\text{Plus}, a, \{\text{Times}, b, c\}\} \\ \end{array} \right)$

I get into trouble, however, when a return value of a captive expression has a value. For instance, something as simple as

x = y
(* Out[10]= y *)
captive[x]
(* Out[11]= y *)


traceView2 reveals that captive inspects the Held input, as required, but that the evaluator apparently snatches it on the way out, and we don't get x, the desired result.

In hindsight, I suppose I shouldn't expect more, since the ever-present term-rewriter (evaluator) is just the way MMA is supposed to work. On a guess, I tried

captive[expr_ /; AtomQ @ Unevaluated @ expr] := Unevaluated @ expr


which doesn't seem to make any difference (and, after reading the docs, I'm not surprised, since Unevaluated only seems to have an effect when supplied in a function-argument slot (see this other question in progress related to behavior of Unevaluated).

I could do

captive[expr_ /; AtomQ @ Unevaluated @ expr] := Hold @ expr


or, better,

captive[expr_ /; AtomQ @ Unevaluated @ expr] := If[ValueQ @ expr, Hold @ expr,expr]


but now my output will always have Hold wrapping symbols that have values. I am beginning to suspect that this may be the best I can do, and I'm prepared to accept that answer (it means that my other function, which frees the captive, will have to have to release the particular holds inserted by this process (and not the Holds that were in the original source expressions!?! which means I probably have to mark them specially, but that's for another topic!)

But before giving up, I thought I'd consult you all, who have already been so generous.

-
please tell me you did not write that latex array by hand... – R. M. Mar 19 '12 at 22:19
"Copy as LaTeX" on right click in MMA -- too easy! – Reb.Cabin Mar 19 '12 at 22:25
I think you almost certainly want something like HoldForm or Defer. – Mr.Wizard Mar 19 '12 at 22:56
helpful Grid-form displays for captive expressions: gist.github.com/2128704 – Reb.Cabin Mar 20 '12 at 0:04

Well, it seems that you just hit the fundamental problem of this approach: any global definition is attached to some symbol. In cases of DownValues, SubValues and perhaps UpValues, this does not harm your approach. But for OwnValues (meaning symbols which have direct values, i.e. variables), it does. You pretty much made this observation yourself. You have to decide which semantics you wish for your function. From what I can tell, you probably do wish to wrap them in some Hold-like wrapper.
However, I would take a different road. I would use Block dynamically, to make a dynamic environment where these symbols are Block-ed, and work in that dynamic environment for whatever code transformations (quoting, etc) you may wish to perform. Yet another approach is to temporarily hide certain symbols with some dummy symbols (assuming that your goal is to make some portions of your code inert and available as data) - I described a very simple version of it here. I actually did write a quoting library based on a combination of these two approaches, for some code-generation purposes, and this worked out quite well for me.
I came up with this as a step along the journey -- captive[expr_ /; AtomQ @ Unevaluated @ expr] := If[ValueQ @ expr, captive @ Evaluate @ expr, expr] – Reb.Cabin Mar 19 '12 at 23:46
@Reb.Cabin To see whether or not this solves your problem I would have to know more about what your problem is. I suspect that this is not a good thing, if your goals are to make some quoting mechanism - because then you probably should operate on code as it stands, and prevent all evaluation - while your first branch of If attempts to evaluate something (an attempt that would in fact fail, because Evaluate is not strong enough to handle HoldAllComplete heads). – Leonid Shifrin Mar 19 '12 at 23:50
forgot to say above -- and MUST change the Attributes from HoldAllComplete to HoldAll. – Reb.Cabin Mar 19 '12 at 23:52