views:

1961

answers:

5

I'd like something like this:

ForEach[i_, {1,2,3},
  Print[i]
]

Or, more generally, to destructure arbitrary stuff in the list you're looping over, like:

ForEach[{i_, j_}, {{1,10}, {2,20}, {3,30}},
  Print[i*j]
]

(Meta-question: is that a good way to call a ForEach loop, with the first argument a pattern like that?)

ADDED: Some answerers have rightly pointed out that usually you want to use Map or other purely functional constructs and eschew a non-functional programming style where you use side effects. I agree! But here's an example where I think this ForEach construct is supremely useful:

Say I have a list of options (rules) that pair symbols with expressions, like

attrVals = {a -> 7, b -> 8, c -> 9}

Now I want to make a hash table where I do the obvious mapping of those symbols to those numbers. I don't think there's a cleaner way to do that than

ForEach[a_ -> v_, attrVals, h[a] = v]

ADDED: I just realized that to do ForEach properly, it should support Break[] and Continue[]. I'm not sure how to implement that. Perhaps it will need to somehow be implemented in terms of For, While, or Do since those are the only loop constructs that support Break[] and Continue[]. If anyone interested in this wants to ask about that as a separate question, please do!

+5  A: 
dreeves
+3  A: 

The built-in Map function does exactly what you want. It can be used in long form:

Map[Print, {1,2,3}]

or short-hand

Print /@ {1,2,3}

In your second case, you'd use "Print[Times@@#]&/@{{1,10}, {2,20}, {3,30}}"

I'd recommend reading the Mathematica help on Map, MapThread, Apply, and Function. They can take bit of getting used to, but once you are, you'll never want to go back!

kchoose2
Thanks! Map is indeed almost always what you want for such things. Scan is actually identical to Map except that it's used strictly for the side effects -- it doesn't return the list.
dreeves
+4  A: 

Newer versions of Mathematica (6.0+) have generalized versions of Do[] and Table[] that do almost precisely what you want, by taking an alternate form of iterator argument. For instance,

Do[
  Print[i],
  {i, {1, 2, 3}}]

is exactly like your

ForEach[i_, {1, 2, 3,},
  Print[i]]

Alterntatively, if you really like the specific ForEach syntax, you can make a HoldAll function that implements it, like so:

Attributes[ForEach] = {HoldAll};

ForEach[var_Symbol, list_, expr_] :=
  ReleaseHold[
    Hold[
      Scan[
        Block[{var = #},
         expr] &,
      list]]];

ForEach[vars : {__Symbol}, list_, expr_] :=
  ReleaseHold[
    Hold[
      Scan[
        Block[vars,
          vars = #;
          expr] &,
      list]]];

This uses symbols as variable names, not patterns, but that's how the various built-in control structures like Do[] and For[] work.

HoldAll[] functions allow you to put together a pretty wide variety of custom control structures. ReleaseHold[Hold[...]] is usually the easiest way to assemble a bunch of Mathematica code to be evaluated later, and Block[{x = #}, ...]& allows variables in your expression body to be bound to whatever values you want.

In response to dreeves' question below, you can modify this approach to allow for more arbitrary destructuring using the DownValues of a unique symbol.

ForEach[patt_, list_, expr_] := 
  ReleaseHold[Hold[
     Module[{f}, 
       f[patt] := expr; 
       Scan[f, list]]]]

At this point, though, I think you may be better off building something on top of Cases.

ForEach[patt_, list_, expr_] :=
  With[{bound = list},
    ReleaseHold[Hold[
       Cases[bound,
         patt :> expr]; 
       Null]]]

I like making Null explicit when I'm suppressing the return value of a function. EDIT: I fixed the bug pointed out be dreeves below; I always like using With to interpolate evaluated expressions into Hold* forms.

Pillsy
I believe this doesn't do the destructuring though. Ie, you can't iterate over data structures where you give the pieces of the data structures their own names, like in my example of iterating over {i,j} pairs. I find that super useful.
dreeves
Is there any advantage to your Hold/ReleaseHold method vs my version that uses an Evaluate? I guess either way you have to set the HoldAll attribute? This is basically Mathematica's version of Lisp macros. It would be nice to have a more general/canonical way to do it. Maybe that's what you've given?
dreeves
The second rule does the destructuring, because Set[] destructures automatically: {i, j} = {3, 4}will set i to 3 and j to 4. I usually prefer the Hold/ReleaseHold approach whenever possible, especially if I can directly substitute things in as function parameters, because it spares me from having to think about what's held and what isn't.And yes, this is basically a somewhat clunky way of doing Lisp macros.
Pillsy
Thanks, this is an edifying discussion! I believe my version is still more general in that it can destructure arbitrary nested structures. Can your version be patched to do that?
dreeves
Yes, I've edited my answer to allow arbitrary, pattern-based destructuring. The more I think about it, though, the more I think Cases is pretty much exactly what you want.
Pillsy
Wow, I just did a speed test and your version with Hold and Cases seems to be over 4 times faster than my version with Scan/Replace/Evaluate. Thanks so much! I'm making yours the accepted answer now.
dreeves
Oops, I found a bug in your Hold/Cases version. If I have a pre-defined list I want to iterate over then, due to the Holds, it doesn't work. Eg, `nums = {1,23}; ForEach[i_, nums, Print[i]];` I guess you just need to do `Evaluate[list]` like I did in my version. Want to update your answer?
dreeves
@dreeves: Done. Thanks for pointing it out. :)
Pillsy
@Pillsy: I may have jumped to a wrong conclusion. I'm having trouble reproducing the supposed bug. Do you know of a case that fails without the With block you just added?
dreeves
@Pillsy: I now believe the supposed bug to have been a false alarm. I had changed the LHS of the ForEach definition to say `ForEach[pat_, lst_List, bod_]` which you can't do for a HoldAll function. Eg, `SetAttributes[f, HoldAll]; f[x_List]:=0; abc={1,2,3}; f[abc]` doesn't evaluate.
dreeves
+1  A: 

Mathematica have map functions, so lets say you have a function Functaking one argument. Then just write

Func /@ list

Print /@ {1, 2, 3, 4, 5}

The return value is a list of the function applied to each element in the in-list.

PrimeQ /@ {10, 2, 123, 555}

will return {False,True,False,False}

Paxinum
Thanks, yes, Map (`/@`) is normally what you want. See my comment to the answer posted Nov 23 though.
dreeves
+2  A: 

I'm years late to the party here, and this is perhaps more an answer to the "meta-question", but something many people initially have a hard time with when programming in Mathematica (or other functional languages) is approaching a problem from a functional rather than structural viewpoint. The Mathematica language has structural constructs, but it's functional at its core.

Consider your first example:

ForEach[i_, {1,2,3},
  Print[i]
]

As several people pointed out, this can be expressed functionally as Scan[Print, {1,2,3}] or Print /@ {1,2,3} (although you should favor Scan over Map when possible, as previously explained, but that can be annoying at times since there is no infix operator for Scan).

In Mathematica, there's usually a dozen ways to do everything, which is sometimes beautiful and sometimes frustrating. With that in mind, consider your second example:

ForEach[{i_, j_}, {{1,10}, {2,20}, {3,30}},
  Print[i*j]
]

... which is more interesting from a functional point of view.

One possible functional solution is to instead use list replacement, e.g.:

In[1]:= {{1,10},{2,20},{3,30}}/.{i_,j_}:>i*j
Out[1]= {10,40,90}

...but if the list was very large, this would be unnecessarily slow since we are doing so-called "pattern matching" (e.g., looking for instances of {a, b} in the list and assigning them to i and j) unnecessarily.

Given a large array of 100,000 pairs, array = RandomInteger[{1, 100}, {10^6, 2}], we can look at some timings:

Rule-replacement is pretty quick:

In[3]:= First[Timing[array /. {i_, j_} :> i*j;]]
Out[3]= 1.13844

... but we can do a little better if we take advantage of the expression structure where each pair is really List[i,j] and apply Times as the head of each pair, turning each {i,j} into Times[i,j]:

In[4]:= (* f@@@list is the infix operator form of Apply[f, list, 1] *)
    First[Timing[Times @@@ array;]]
Out[4]= 0.861267

As used in the implementation of ForEach[...] above, Cases is decidedly suboptimal:

In[5]:= First[Timing[Cases[array, {i_, j_} :> i*j];]]
Out[5]= 2.40212

... since Cases does more work than just the rule replacement, having to build an output of matching elements one-by-one. It turns out we can do a lot better by decomposing the problem differently, and take advantage of the fact that Times is Listable, and supports vectorized operation.

The Listable attribute means that a function f will automatically thread over any list arguments:

In[16]:= SetAttributes[f,Listable]
In[17]:= f[{1,2,3},{4,5,6}]
Out[17]= {f[1,4],f[2,5],f[3,6]}

So, since Times is Listable, if we instead had the pairs of numbers as two separate arrays:

In[6]:= a1 = RandomInteger[{1, 100}, 10^6];
        a2 = RandomInteger[{1, 100}, 10^6];

In[7]:= First[Timing[a1*a2;]]
Out[7]= 0.012661

Wow, quite a bit faster! Even if the input wasn't provided as two separate arrays (or you have more than two elements in each pair,) we can still do something optimal:

In[8]:= First[Timing[Times@@Transpose[array];]]
Out[8]= 0.020391

The moral of this epic is not that ForEach isn't a valuable construct in general, or even in Mathematica, but that you can often obtain the same results more efficiently and more elegantly when you work in a functional mindset, rather than a structural one.

Michael Pilat
Beautifully said. Thanks for this contribution. An example of where I find ForEach useful is creating a hash table. Say I have a list of data structures; then I could walk through them with, say, `ForEach[{i_, {j_, k_}}, listofstuff, hash[f[i,k] = g[j,k]]`.
dreeves