How to pass a symbol name to a function with any of the Hold attributes?

Question

Given a function with the attribute HoldFirst, HoldAll or similar, and a variable, list, how can I pass the variable's name to the function without the variable being evaluated prematurely? So it is "list" that is to be passed to the function (e.g. AppendTo) instead of list.

The following method fails, as AppendTo holds the evaluation of Symbol @ "list", and since Symbol[...] is not a valid variable for which a value can be assigned, an error message appears:

list = {1, 2, 3};
AppendTo[Symbol @ "list", 1];
list

Set::write: Tag Symbol in Symbol[list] is Protected.>>

{1, 2, 3}

I should mention, that for certain reasons the obvious direct assignment below is not possible, as I must pass the list as a string:

list = {1, 2, 3};    
list = Append[list, 2]; (* this works, but is not what I am looking for *)

{1, 2, 3, 2}

The next approach also fails, as it issues an error message while returning the correct result:

list = {1, 2, 3};
held = AppendTo[Evaluate @ ToExpression["list", InputForm, Hold], 3];
ReleaseHold @ held;
list

AppendTo::rvalue: Hold[list] is not a variable with a value, so its value cannot be changed.>>

{1, 2, 3, 3}

The final approach reveals that ReleaseHold removes the outermost Hold, but leaves the innermost intact.

list = {1, 2, 3};
held = Hold @ AppendTo[Evaluate@ToExpression["list", InputForm, Hold], 4];
ReleaseHold @ held

AppendTo::rvalue: Hold[list] is not a variable with a value, so its value cannot be changed.>>

AppendTo[Hold[list], 4]

Answer 1

How about this:

list = {1, 2, 3};
ToExpression["list", InputForm, Hold] /. Hold[v_] :> AppendTo[v, 3]

{1, 2, 3, 3}

list

{1, 2, 3, 3}

Answer 2

Not to detract from the existing answers (particularly @WReach's suggestion, which was the same solution that came to my mind as I read your question, and which I will use here), but you may find it easier to define your own references rather than using strings. (In fact, I wouldn't necessarily recommend an approach based on building Mathematica expressions out of strings as a good first choice in general.) The advantage of using your own operator is that it will be easier to get rid of it when you don't want it any more, and no complex syntax is needed to actually use it.

First, let us define the reference object (which is essentially just a wrapper):

Attributes[referenceTo] = {HoldAll, Listable};

referenceTo[str_String] :=
  referenceTo[Evaluate@ToExpression[str, InputForm, Hold]];

referenceTo@Hold[sym_Symbol] := referenceTo[sym];

referenceTo /: f_[argsPre___, ref : referenceTo[str_String], argsPost___] := 
 f[argsPre, Evaluate[ref], argsPost]

We can either use this directly, or on strings. For example:

{a, b, c} = Range[3]; (* make some definitions to prove it works *)

referenceTo[{"a", b, Hold[c]}]
    (* -> {referenceTo[a], referenceTo[b], referenceTo[c]} *)

So, while very simple, the behaviour of the wrapper is probably sufficient for most purposes in terms of creating the references in the first place (and, of course, the range of situations in which it is recognized can readily be expanded if necessary). Now we tell it when and how to dereference the symbols it wraps:

$dereferencingFunctions = {AppendTo, ReleaseHold};
referenceTo /: f_[argsPre___, referenceTo[sym_Symbol], argsPost___] /; 
 MemberQ[$dereferencingFunctions, f] :=
  f[argsPre, sym, argsPost]

You can now manipulate $dereferencingFunctions to switch this behaviour on and off for different functions as required and avoid the need for manual dereferencing as part of each call. Thus,

list = {elem1};
AppendTo[referenceTo[list], elem2];
stuff = elem3;
AppendTo[referenceTo["list"], referenceTo[stuff]];
(* a rather odd way to use it, but possibly useful: *)
AppendTo @@ referenceTo[{"list", elem4}];

evaluates correctly and without producing any messages, and gives:

list
    (* -> {elem1, elem2, elem3, elem4} *)

Or, if you prefer:

ReleaseHold@referenceTo["list"]
    (* -> {elem1, elem2, elem3, elem4} *)

In my opinion, despite its extreme simplicity, this approach manages to be much more practical than using strings directly.

Answer 3

Injector pattern:

list = {1, 2, 3};

MakeExpression["list"] /. _[sym_] :> AppendTo[sym, 4]

Function (here using the Null syntax trick):

Function[, AppendTo[#, 4], HoldAll] @@ MakeExpression["list"]

Answer 4

Here is yet another possibility (which, in a way, combines some of the suggestions given already): define a new scoping construct, most similar to Function, to perform the task you need:

ClearAll[strFunction];
SetAttributes[strFunction, HoldAll];
SyntaxInformation[strFunction] =
     {"ArgumentsPattern" -> {_, _}, "LocalVariables" -> {"Solve", {1, 1}}};
strFunction[var_, expr_] :=
   Function[strvar,
      ToExpression[strvar, InputForm,
          Function[held, 
             Unevaluated[expr] /.HoldPattern[var] :> held, 
             HoldAll
          ]
      ]
   ];

You can use it as:

list = {1, 2, 3};
strFunction[l, AppendTo[l, 1]]["list"]

Mapping on a list of such names is also quite easy in this approach:

Map[strFunction[l, AppendTo[l, 1]], list-of-symbol-names]

You can also add type-checks, generalize to functions with more than one variable, etc.

Answer 5

This works:

ReleaseHold@Block[{list},Hold[AppendTo["list",1]]/."list"->Symbol["list"]]

The mechanism is as follows:

• The block temporarily undefines list so that after Symbol["list"] is evaluated, evaluation stops.
• However, the AppendTo shall not be evaluated as long as list is undefined, therefore it is wrapped in Hold.
• Symbol shall be evaluated, therefore it may not be inside Hold. For this reason, it is injected into the Hold expression with a replacement rule.
• When leaving the block, list gets back its old definition, therefore all we have to do now is to remove the Hold so that the generated AppendTo expression is evaluated.