8

Consider the following approach to modifying a list:

updateList01[lst_List, test_] :=
 Module[{xs = lst}, If[test, xs[[1]] += 1]; xs]
lst = {1, 2, 3}
lst = updateList[lst, True]

The good: all arguments are passed explicitly. The bad: xs and lst are apparently both entirely in memory(?). If that is right, what is the Mathematica idiom to avoid building a (potentially large) second list? (Assume there are many lists that needed to be updated and that actual updating is more complex.) Looking at HoldFirst, it sounds like I might avoid a copy by setting HoldFirst. That is also how I am inclined to read How to modify function argument?. Is that a correct interpretation? But even if one can avoid a copy this way, I'm clearly failing to understand something. The following fails:

SetAttributes[updateList02, HoldFirst]
updateList02[lst_List, test_] := If[test, lst[[1]] += 1]
lst02 = {1, 2, 3}
updateList02[lst02, True]  (* Not evaluated? *)
lst02   (* Unchanged *)

How do I fix it?

Community
  • 1
Alan
  • 13,686
  • 19
  • 38
  • 3
    I'm not sure what the problem is yet, but it seems like the Hold attribute is preventing MMA from noticing that lst02 is a List, so you're head specification isn't matched, which is why it's not evaluating. You'll also run into a problem because you actually want to modify what is located in lst02, try defining updateList02[lst_Symbol,test_]:=...what you have. – N.J.Evans Nov 03 '15 at 16:29
  • I guess the OP wants the updating function to remain pure so it can be applied to any lists, but also doesn't want the list to be duplicated inside the function. In other words, I guess he wants to pass just something like the pointer to a global list into the function à la C. – Taiki Nov 03 '15 at 16:33
  • @Taiki, I think Symbol plays the role of the pointer here. If you want to check that the object represented by the symbol is a list you should do something like update[lst_Symbol,test_]/;Head[ReleaseHold@lst]==List:= ...your function... – N.J.Evans Nov 03 '15 at 16:46
  • 1
    @N.J.Evans Yeah I know. I just wanted to point out what the problem was, despite that your comment is already a fix to it. :) – Taiki Nov 03 '15 at 16:49
  • 2
    @N.J.Evans, Head doesn't hold its argument so the ReleaseHold isn't required. – Simon Woods Nov 03 '15 at 16:51
  • 4
    Mathematica is smart and it doesn't store duplicate arrays. Even explicit lst03=lst02 is lazy. However there is one important (and weird) thing: set $HistoryLength = 0 before dealing with big arrays! – ybeltukov Nov 03 '15 at 17:16
  • @ybeltukov I this case however the modified list does cause a duplication, does it not? At least that appears so in a quick test in v10.1.0. – Mr.Wizard Nov 03 '15 at 19:01
  • @Mr.Wizard Yes, any modification of packed array causes its duplication. However you can partially modify list of packed arrays without a duplication. Here is my test. – ybeltukov Nov 03 '15 at 20:10

1 Answers1

9

You've actually got two problems. The first is the fact that the function isn't evaluating. This happens because you pass lst02 to your function, which is a Symbol not, a List, so the pattern doesn't match your definition. You can see this by doing:

SetAttributes[updateList02, HoldFirst]
updateList02[lst_List, test_] := If[test, lst[[1]] += 1]
lst02 = {1, 2, 3}
updateList02[Evaluate@lst02, True]  
lst02   (* still unchanged *)

This evaluates, but not in the way you wanted it to.

Since you're trying to change the stuff referred to as lst02, write your function to accept the Symbol referring to the stuff you're trying to modify. But since you lost your original pattern match you'll need to make sure you only evaluate the function for lists, which you can do with a conditional:

ClearAll[updateList02];
SetAttributes[updateList02, HoldFirst]
updateList02[lst_Symbol, test_] /; Head@lst == List := 
 If[test, lst[[1]] += 1];

Now doing

lst02={1,2,3};
updateList02[lst02,True];
lst02

gives {2,2,3}

You can also use the conditional to add other safety measures, make sure your list is long enough etc.

N.J.Evans
  • 5,093
  • 19
  • 25
  • 4
    The semi-documented ListQ can be used tersely with PatternTest: updateList02[lst_Symbol?ListQ, test_] := . . . – Mr.Wizard Nov 03 '15 at 19:00