Цикл ForEach в системе Mathematica

Встроенный Scan в основном так и делает, хотя и уродливее:

    Scan[Print[#]&, {1,2,3}]

Это особенно уродливо, когда вы хотите деструктурировать элементы:

    Scan[Print[#[[1]] * #[[2]]]&, {{1,10}, {2,20}, {3,30}}]

Следующая функция позволяет избежать уродства путем преобразования pattern в body для каждого элемента list.

SetAttributes[ForEach, HoldAll];
ForEach[pat_, lst_, bod_] :=  Scan[Replace[#, pat:>bod]&, Evaluate@lst]

который можно использовать, как в примере в вопросе.

PS: Принятый ответ побудил меня переключиться на это, что я использую с тех пор, и, похоже, он отлично работает (за исключением оговорки, которую я добавил к вопросу):

SetAttributes[ForEach, HoldAll];             (* ForEach[pattern, list, body]   *)
ForEach[pat_, lst_, bod_] := ReleaseHold[    (*  converts pattern to body for  *)
  Hold[Cases[Evaluate@lst, pat:>bod];]];     (*   each element of list.        *)

Встроенная функция карты делает именно то, что вы хотите. Его можно использовать в развернутой форме:

Карта [Печать, {1,2,3}]

или короткая рука

Печать / @ {1,2,3}

Во втором случае вы должны использовать «Print [Times @@ #] & / @ {{1,10}, {2,20}, {3,30}}»

Я бы рекомендовал прочитать справку Mathematica по Map, MapThread, Apply и Function. К ним можно немного привыкнуть, но однажды вы никогда не захотите возвращаться!

В новых версиях Mathematica (6.0+) есть обобщенные версии Do [] и Table [], которые делают почти то, что вы хотите, за счет использования альтернативной формы аргумента итератора. Например,

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

в точности как ваш

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

В качестве альтернативы, если вам действительно нравится конкретный синтаксис ForEach, вы можете создать функцию HoldAll, которая его реализует, например:

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]]];

Здесь в качестве имен переменных используются символы, а не шаблоны, но именно так работают различные встроенные управляющие структуры, такие как Do [] и For [].

Функции HoldAll [] позволяют собрать довольно широкий спектр настраиваемых управляющих структур. ReleaseHold [Hold [...]] - обычно самый простой способ собрать кучу кода Mathematica для последующей оценки, а Block [{x = #}, ...] & позволяет привязать переменные в теле выражения к любые ценности, которые вы хотите.

В ответ на вопрос Дрейва ниже вы можете изменить этот подход, чтобы обеспечить более произвольную деструктуризацию с использованием DownValues ​​уникального символа.

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

На данном этапе, однако, я думаю, вам лучше создать что-нибудь на основе кейсов.

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

Мне нравится делать Null явным, когда я подавляю возвращаемое значение функции. РЕДАКТИРОВАТЬ: Я исправил ошибку, указанную ниже; Мне всегда нравится использовать With для интерполяции вычисленных выражений в формы Hold*.

В Mathematica есть функции карты, поэтому допустим, у вас есть функция Func, принимающая один аргумент. Тогда просто напишите

Func /@ list

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

Возвращаемое значение - это список функций, примененных к каждому элементу в списке.

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

вернет {False,True,False,False}

Я на много лет опоздал на вечеринку, и это, возможно, скорее ответ на «мета-вопрос», но то, с чем многим людям изначально трудно, когда программирование на Mathematica (или других функциональных языках) приближается к проблеме из функциональная, а не структурная точка зрения. Язык Mathematica имеет структурные конструкции, но по своей сути он функциональный.

Рассмотрим свой первый пример:

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

Как указали несколько человек, функционально это можно выразить как Scan[Print, {1,2,3}] или Print /@ {1,2,3} (хотя вы должны отдавать предпочтение Scan, а не Map, когда это возможно, как ранее объяснялось, но иногда это может раздражать, поскольку для Scan нет инфиксного оператора).

В Mathematica обычно есть дюжина способов сделать все, что иногда красиво, а иногда расстраивает. Имея это в виду, рассмотрим второй пример:

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

... что более интересно с функциональной точки зрения.

Одно из возможных функциональных решений - вместо этого использовать замену списком, например:

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

... но если бы список был очень большим, это было бы излишне медленно, поскольку мы выполняем так называемое «сопоставление с образцом» (например, ищем экземпляры {a, b} в списке и назначаем их i и j) без надобности.

Учитывая большой массив из 100000 пар, array = RandomInteger[{1, 100}, {10^6, 2}], мы можем посмотреть на некоторые тайминги:

Замена правила выполняется довольно быстро:

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

... но мы можем добиться большего, если воспользуемся структурой выражения, в которой каждая пара действительно является List[i,j], и применим Times в качестве главы каждой пары, превратив каждый {i,j} в 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

При использовании в реализации ForEach[...] выше, Cases явно неоптимален:

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

... поскольку Cases выполняет больше работы, чем просто замену правила, ему нужно создавать вывод совпадающих элементов один за другим. Оказывается, мы можем сделать много лучше, разложив проблему по-другому и воспользовавшись тем фактом, что Times - это Listable и поддерживает векторизованные операции.

Атрибут Listable означает, что функция f будет автоматически обрабатывать любые аргументы списка:

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]}

Итак, поскольку Times - это Listable, если бы вместо этого у нас были пары чисел как два отдельных массива:

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

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

Вау, совсем немного быстрее! Даже если входные данные не были представлены в виде двух отдельных массивов (или у вас более двух элементов в каждой паре), мы все равно можем сделать что-то оптимальное:

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

Мораль этой эпопеи заключается не в том, что ForEach не является ценной конструкцией в целом или даже в системе Mathematica, а в том, что вы часто можете получить те же результаты более эффективно и элегантно, работая с функциональным мышлением, а не со структурным. .

Благодаря Pillsy и Леонид Шифрин вот что я сейчас использую:

SetAttributes[each, HoldAll];               (* each[pattern, list, body]      *)
each[pat_, lst_List, bod_] :=               (*  converts pattern to body for  *)
  (Cases[Unevaluated@lst, pat:>bod]; Null); (*   each element of list.        *)
each[p_, l_, b_] := (Cases[l, p:>b]; Null); (* (Break/Continue not supported) *)

Вот небольшое улучшение, основанное на последнем ответе dreeves, которое позволяет указывать шаблон без пустого поля (делая синтаксис похожим на другие функции, такие как Table или Do) и который использует аргумент уровня Cases

SetAttributes[ForEach,HoldAll];
ForEach[patt_/; FreeQ[patt, Pattern],list_,expr_,level_:1] :=
   Module[{pattWithBlanks,pattern},
      pattWithBlanks = patt/.(x_Symbol/;!MemberQ[{"System`"},Context[x]] :> pattern[x,Blank[]]);
      pattWithBlanks = pattWithBlanks/.pattern->Pattern;

      Cases[Unevaluated@list, pattWithBlanks :> expr, {level}];
      Null
   ];

Тесты:

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