How to return the unevaluated variable names from a list of variables which have been declared

Question

I feel like this should have a simple answer but I haven't found anything that works. The toy example of what I want is as follows:

testx = 1;
testy = 2;
testlist = {testx, testy};

And I'm looking for a function that I could use on testlist (f[testlist]) that will return {testx, testy} in their unevaluated symbols or strings.

I've tried OwnValues, Values, Variables, Information, and various others along with their permutations. My intuition says that some combination of pure functions could do what I want, but I'm still very unsure of how to use most of them.

Edit*

Some context for this problem: I am procedurally defining a function (for example):

func = Sum[ToExpression["a"<>ToString[i]],{i, 1, large_number}]

Separately I generate a list of the variable names which occur in the defintion, like shown above, except in this case it would appear as

varsList = {a1, a2, ... , a<large_number>}

And I wish to be able to procedurally select the string or undeclared variable symbol from varsList for use in manipulate.

Edit 2*

I'm doing a terrible job asking this question. What I'm attempting to do is use the answer provided here, which allows for manually adjusting parameters within manipulate and then using those manually determined values as starting values for a fit, finally feeding the best-fit values back into the current values for the parameters and allowing for subsequent manual control.

Except in my case, the function must have variable number of parameters. I already procedurally generate my function (as above). But am stuck on how to generate the Sequence of parameters inside manipulate, as well as how to call the symbols for resetting their values to those of the best-fit results. That is the ultimate goal and apparently my previous attempts are not possible.

Final Edit*

I've improved the manipulate functionality shown here to also include procedural generation of a function with variable number of parameters.

To do so required applying Hold to the function and its variables, but this alone was not enough because any attempt to redefine the variables on the LHS of an equation was met with simply trying to define a number as another number. The solution was then to construct the line of code I wanted to run entirely as a string, then Evaluate[ToExpression[[]] it. Code below should run as is, the 4 in testplotfit[] may be changed to any positive integer between 1 and 10 currently, determined by the internal clear command. I truly do wonder why there is no better, or at least more well-known, way to procedurally redefine previously assigned variables.

data = Table[{x, 
    8 x^3 - 7 x^2 - 10 x + 1 + RandomReal[{-5, 5}]}, {x, -2, 2, 0.1}];


function[terms_] := 
  Sum[ToExpression["a" <> ToString[i]]*x^(i - 1), {i, terms}];
functiontemp[terms_] := 
  Sum[ToExpression["b" <> ToString[i]]*x^(i - 1), {i, terms}];

testplotfit[terms_] := DynamicModule[{(*sol, solString*)},
   ClearAll[Evaluate[Sequence @@ Table["a" <> ToString[i], {i, 10}]]];
   funcString = TextString[function[terms]];
   vars = 
    Thread[Hold@Evaluate[DeleteCases[Variables[function[terms]], x]]];
   varsString = ToString[vars[[All, 1]]];
   tempvars = 
    Table[ToExpression["b" <> ToString[i]], {i, Length[vars]}];
   solString = ConstantArray["blank", terms];

   Manipulate[
      If[computeFlag == True,
       Evaluate[
        sol = 
          FindFit[data, functiontemp[terms], 
           Table[{tempvars[[i]], ReleaseHold[vars[[i]]]}, {i, 
             Length[vars]}], x];
        ];
       Evaluate[
        ToExpression[
         varsString <> " = " <>(*ToString[solString]*)
          ToString[tempvars /. sol]]];
       computeFlag = False;
       ];

      Column[
       {Dynamic[Button["Compute", computeFlag = True]],
        Show[
         Plot[#, {x, -2, 2}, PlotStyle -> Black],
         ListPlot[data, PlotStyle -> Red],
         ImageSize -> 300,
         PlotRange -> {{-2.05, 2.05}, All}]}
       ]

      (*;sol*),

      {{computeFlag, False}, ControlType -> None},
      Evaluate[
       Sequence @@ 
        Table[{{i, 1}, -10, 10, Appearance -> "Open"}, {i, 
          vars[[All, 1]]}]],
      LocalizeVariables -> False
      ] &@function[terms] (*end of Manipulate*)
   ];

testplotfit[4]

Answer 1

Why not use 'Hold' ?

testx = 1; testy = 2; testlist = Hold@{testx, testy}
Hold[{testx, testy}]
Thread[%]
{Hold[testx], Hold[testy]}

For the variable names, I would use :

Names["a*"]
{"a1", "a2", "a3", "a4"}

which gives a list of variable names as strings. Those can be turned into variables by

ToExpression

Answer 2

Please don't use this in practice, but as an exercise here is literal solution to your original question. This requires an input history long enough to contain the set line.

$HistoryLength = 100;

testx = 1;
testy = 2;
testlist = {testx, testy};

Attributes[fn] = HoldFirst;
fn[s_Symbol] :=
 Cases[Reverse @ DownValues @ In, (Set | SetDelayed)[HoldPattern[s], body_] :> 
    HoldForm[body], {1, -1}, 1][[1]]

fn[testlist]

{testx, testy}   (* wrapped in HoldForm *)

Reference: $HistoryLength, In, HoldForm, Attributes, HoldFirst

For a more practical approach you may find these questions helpful:

• How do I evaluate only one step of an expression?
• Assigning values to a list of variable names
• Elegant manipulation of the variables list