Надежная очистка в Mathematica

Ответ 1

Отличный вопрос, но я не согласен с тем, что семантика Return мутная; Они задокументированы в предоставляемой вами ссылке. Короче говоря, Return завершает самую внутреннюю конструкцию (а именно, структуру управления или определение функции), в которой он вызывается.

Единственный случай, когда функция CleanUp выше не очищается от Return, - это когда вы напрямую передаете один или CompoundExpression (например, (one;two;three) непосредственно в качестве входных данных).

Возврат завершает функцию f:

In[28]:= f[] := Return["ret"]

In[29]:= CleanUp[f[], Print["cleaned"]]

During evaluation of In[29]:= cleaned

Out[29]= "ret"

Return завершает x:

In[31]:= x = Return["foo"]

In[32]:= CleanUp[x, Print["cleaned"]]

During evaluation of In[32]:= cleaned

Out[32]= "foo"

Return завершает цикл Do:

In[33]:= g[] := (x = 0; Do[x++; Return["blah"], {10}]; x)

In[34]:= CleanUp[g[], Print["cleaned"]]

During evaluation of In[34]:= cleaned

Out[34]= 1

Возвращает из тела CleanUp в точке, где body оценивается (поскольку CleanUp есть HoldAll):

In[35]:= CleanUp[Return["ret"], Print["cleaned"]];

Out[35]= "ret"

In[36]:= CleanUp[(Print["before"]; Return["ret"]; Print["after"]), 
 Print["cleaned"]]

During evaluation of In[36]:= before

Out[36]= "ret"

Как я уже отмечал выше, последние два примера являются единственными проблемными случаями, которые я могу придумать (хотя я мог ошибаться), но их можно обработать, добавив определение в CleanUp:

In[44]:= CleanUp[CompoundExpression[before___, Return[ret_], ___], form_] := 
           (before; form; ret)

In[45]:= CleanUp[Return["ret"], Print["cleaned"]]

During evaluation of In[46]:= cleaned

Out[45]= "ret"

In[46]:= CleanUp[(Print["before"]; Return["ret"]; Print["after"]), 
 Print["cleaned"]]

During evaluation of In[46]:= before

During evaluation of In[46]:= cleaned

Out[46]= "ret"

Как вы сказали, не собирайтесь побеждать в конкурсах красоты, но, надеюсь, это поможет решить вашу проблему!

Ответ на ваше обновление

Я бы сказал, что использование Return внутри If не требуется и даже злоупотребление Return, учитывая, что If уже возвращает либо второй, либо третий аргумент, основанный на состоянии условия в первом аргумент. Хотя я понимаю, что ваш пример, вероятно, надуман, If[3==3, Return["Foo"]] функционально идентичен If[3==3, "foo"]

Если у вас более сложный оператор If, вам лучше использовать Throw и Catch, чтобы вырваться из оценки и "вернуть" что-то в точку, в которую вы хотите, чтобы она была возвращена.

Тем не менее, я понимаю, что вы не всегда можете контролировать код, который нужно очистить после, так что вы всегда можете перенести выражение в CleanUp в структуру управления no-op, например:

ret1 = Do[ret2 = expr, {1}]

..., злоупотребляя Do, чтобы заставить Return не содержаться в структуре управления в expr для возврата из цикла Do. Единственная сложная часть (я думаю, не пробовав это) - иметь дело с двумя разными значениями возврата выше: ret1 будет содержать значение незанятого Return, но ret2 будет иметь значение любой другой оценки of expr. Вероятно, есть более чистый способ справиться с этим, но я не вижу его прямо сейчас.

НТН!

Ответ 2

Pillsy более поздняя версия CleanUp - хорошая. Из-за опасности быть педантичным, я должен указать на неприятный случай использования:

Catch[CleanUp[Throw[23], Print["cleanup"]]]

Проблема связана с тем, что нельзя явно указать шаблон тега для Catch, который будет соответствовать немаркированному Throw.

Следующая версия CleanUp адресует эту проблему:

SetAttributes[CleanUp, HoldAll]
CleanUp[expr_, cleanup_] :=
  Module[{exprFn, result, abort = False, rethrow = True, seq},
    exprFn[] := expr;
    result = CheckAbort[
      Catch[
        Catch[result = exprFn[]; rethrow = False; result],
        _,
        seq[##]&
      ],
      abort = True
    ];
    cleanup;
    If[abort, Abort[]];
    If[rethrow, Throw[result /. seq -> Sequence]];
    result
  ]

Увы, этот код еще менее вероятен для конкуренции в конкурсе красоты. Более того, меня не удивило бы, если бы кто-то вскочил с еще одним нелокальным потоком управления, который этот код не будет обрабатывать. Даже в маловероятном случае, когда он будет обрабатывать все возможные случаи, проблематичные случаи могут быть введены в Mathematica X (где X > 7.01).

Я боюсь, что окончательный ответ на эту проблему не может быть до тех пор, пока Wolfram не представит для этой цели новую структуру управления. UnwindProtect будет прекрасным именем для такого объекта.

Ответ 3

Майкл Пилат предоставил ключевой трюк для "ловушек", но я в конечном итоге использовал его несколько иначе, используя тот факт, что Return заставляет возвращаемое значение именованной функции, а также структуры управления, такие как Do. Я сделал выражение, которое очищается после значения вниз локального символа, например:

Attributes[CleanUp] = {HoldAll};
CleanUp[expr_, form_] :=
  Module[{body, value, aborted = False},

   body[] := expr;

   Catch[
    CheckAbort[
     value = body[],
     aborted = True];
    form;
    If[aborted,
     Abort[],
     value],
    _, (form; Throw[##]) &]];