programming - Modifying a List in a function in place

An example will be most specific:

func[list_, column_] := list[[All, column]] = Map[#*2 &, list[[All, column]]];

This throws errors.

I want to avoid doing something like this:

func2[list_] := Map[#*2 &; list];

list[[All, 2]] = func2[list[[All,2]]]

because nesting a couple of functions raises complexity unnecessarily, the output would have to be reassigned every time.

Thanks in advance.

As a followup, using HoldFirst works fine, but using the so defined function in a Map gives again errors.

The setup is as follows:

create a nested list

testList = Table[Table[{x y, x y 2}, {x, 1,3}], {y,1,3}]

define afunc with HoldFirst Attribute

afunc = Function[{list, col}, list[[All, col]] = Map[# * 2 &, list[[All, col]]], HoldFirst]

and another function using the first

bfunc[nestedList_, col_] := Map[afunc[#, col] &, nestedList]

now, a call to

bfunc[testList, 2]

should alter the 2'nd columns of the nested lists I'd expect, but it instead throws errors

i've tried to set Attribute HoldFirst on this function as well but it didn't work out as expected

Answer

You basically need a pass-by-reference semantics, which in Mathematica can be emulated with Hold-attributes. Add a HoldFirst attribute to your function:

SetAttributes[func,HoldFirst]

and you should be fine. Without it, list evaluates to its value before the assignment is attempted, and since expressions in Mathematica are immutable, you get an error.

To address your question in comments, the one-liner you asked for can be this:

func = Function[{list,column}, 
         list[[All, column]] = Map[#*2 &, list[[All, column]]],
         HoldFirst
       ]

Note however that, since this is a pure function, you can not do argument checks as elegantly as you can with patterns, and you can not overload your functions on different arguments as elegantly.

Note also that, while yet another way to do this is to keep your function as it is but rather wrap the first argument in Unevaluated in every function call, I would strongly advise against that. The reason is that it makes the function itself not self-contained, because it has to assume that the user will always remember to use Unevaluated (which it shouldn't), and there is no way to test whether or not the user actually did use it.