Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

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_[args___]] := 
    {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.

captive fail

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.

share|improve this question
1  
please tell me you did not write that latex array by hand... –  rm -rf Mar 19 '12 at 22:19
2  
"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
1  
helpful Grid-form displays for captive expressions: gist.github.com/2128704 –  Reb.Cabin Mar 20 '12 at 0:04

1 Answer 1

up vote 7 down vote accepted

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.

share|improve this answer
    
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
    
Btw, apologies for a meta comment, I have a really nice Grid function for displaying the "S-Expressions" resulting from this "captive" that I'd like to share. Maybe I should put it up in a github repo? Too big for a comment and not appropriate for an "answer" here, unless you advise otherwise. –  Reb.Cabin Mar 19 '12 at 23:48
    
@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
    
@Reb.Cabin You can e.g. use GitHub gists, which give an easy way to share smaller projects / code fragments/ files. You can make a gist with this, and then link to it from your question, as an additional remark. At least, that's probably what I would do. You can have more than one file in a gist. –  Leonid Shifrin Mar 19 '12 at 23:55

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

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