How can I adjust the global input variable of a function to the value of a local variable within the function

Question

I am trying to define a function f[l_] that will perform an operation on whatever input variable I use (normally I use l which is a list like {2,2,2} or the like) and then reassign the value of the input variable to be the the newly changed list.

The catch is that I'm working within a Module, so the list is adjusted locally within my function f[l_] and the output is the correctly changed list. After I perform the operation, however, the input variable l is still the same: {2,2,2}.

I don't know how to code my function so that the input variable (whether I use l or x or iamstrugglingwiththis as the argument for my function) is changed to be the correct output that is given to me.

Answer 1

I think that you are looking for something analogous to various modify-in-place functions such as AddTo, AppendTo, PrependTo, AssociateTo, SubtractFrom, Increment, Decrement, but for general function application.

Being aware of Apply and bearing in mind the difference in meaning between simply "function application" and the specific operation of Apply I shall risk to define a function applyTo. Most basically:

SetAttributes[applyTo, HoldFirst]
applyTo[obj_, fn_] := obj = fn[obj]

Now:

a = {2, 2, 2};

applyTo[a, 2 # &];

a

{4, 4, 4}

Since Set works with assignments to Part so does this construct:

applyTo[a[[1]], Sqrt];
applyTo[a[[2]], foo];

a

{2, foo[4], 4}

Answer 2

I interpret this question as asking how define a function that works like the built-in functions Part, AppendTo, and PrependTo; i.e., a function that performs non-standard argument evaluation because it has been given one of the attributes from the Hold family of attributes.

Normally, in what is referred to as standard evaluation, all the actual arguments passed to a function are evaluated before the function sees them. For a function to able to modify the binding of a global variable it must see that variable's identifier unevaluated. Mathematica provides a mechanism for achieving this with what it calls attributes. For more about standard evaluation, nonstandard evaluation, and attributes mean, you should read the collection of articles found here.

Now I will present an example showing nonstandard evaluation applied to a situation like the one you describe, which involves a module. I have picked a somewhat more elaborate example than Mr.Wizard did in order to illustrate more of the issues that come up when dealing with nonstandard evaluation.

SetAttributes[procrustes, HoldAll];
procrustes[victum_, size_] :=
  Module[{v = victum, n = size},
    If[! (Head[n] === Integer && n > 0), Return[$Failed]];
    If[Head[v] =!= List || v === {}, Return[$Failed]];
    Unevaluated[victum] = If[Length[v] >= size, v[[;; n]], PadRight[v, n, v]];]

Some unit tests

Block[{v = {a, b, c}}, (procrustes[v, #]; v) & /@ {5, 3, 3, 1}]

{{a, b, c, a, b}, {a, b, c}, {a, b, c}, {a}}

Block[{a = 42, b = Pi, c = {}}, procrustes[#, 1] & /@ {a, b, c, 0}]

{$Failed, $Failed, $Failed, $Failed}

Block[{v = {1}, a = 42., b = Pi, c = {}}, procrustes[v, #] & /@ {a, b, c, 0}]

{$Failed, $Failed, $Failed, $Failed}

When defining a function that uses standard evaluation, I make heavy use of argument patterns to validate actual arguments. When defining a function with nonstandard evaluation, I forego that luxury and fall back on procedural argument validation as I have shown here, the reason being that the argument patterns needed become at best awkward in the nonstandard case.