Безопасная настройка структуры в Mathematica

Во-первых, я хотел бы отметить, что все перечисленные вами методы являются ошибочными и опасными. Основная причина, по которой они мне не нравятся, заключается в том, что они вводят неявные зависимости от глобальных переменных (причины, почему это плохо, обсуждаются, например, здесь), а также может испортить область видимости. Другая их проблема заключается в том, что эти подходы выглядят так, как будто они не будут хорошо масштабироваться для многих экземпляров ваших структур, существующих одновременно. Второй метод, который вы перечислили, кажется самым безопасным, но и у него есть свои проблемы (строки в качестве имен полей, нет возможности проверить тип такой структуры, также символы, используемые там, могут случайно иметь значение).

В моем сообщении здесь я обсуждал возможный способ создания изменяемых структур данных. где методы могут выполнять дополнительные проверки. Я скопирую соответствующий фрагмент здесь:

Unprotect[pair, setFirst, getFirst, setSecond, getSecond, new, delete];
ClearAll[pair, setFirst, getFirst, setSecond, getSecond, new, delete];
Module[{first, second},
   first[_] := {};
   second[_] := {};
   pair /: new[pair[]] := pair[Unique[]];
   pair /: new[pair[],fst_?NumericQ,sec_?NumericQ]:= 
      With[{p=new[pair[]]}, 
          p.setFirst[fst];
          p.setSecond[sec];
          p];
   pair /: pair[tag_].delete[] := (first[tag] =.; second[tag] =.);
   pair /: pair[tag_].setFirst[value_?NumericQ] := first[tag] = value;
   pair /: pair[tag_].getFirst[] := first[tag];
   pair /: pair[tag_].setSecond[value_?NumericQ] := second[tag] = value;
   pair /: pair[tag_].getSecond[] := second[tag];       
];
Protect[pair, setFirst, getFirst, setSecond, getSecond, new, delete]; 

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

Теперь ваш пример будет выглядеть так:

foo[from_?NumericQ, to_?NumericQ] :=
   Module[{}, Plot[Sin[x], {x, from, to}]];
foo[p_pair] := foo[p.getFirst[], p.getSecond[]]
pp = new[pair[], -Pi, Pi];
foo[pp]

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

В системе Mathematica 10 появился Association, обладающий многими наиболее важными свойствами struct (и имеет синтаксис, аналогичный правилам замены, с которыми вы экспериментировали).

plotLimits = <| "lowerLimit" -> -Pi, "upperLimit" -> Pi |>; 
(*this is the syntax for an Association[]*)

foo[p_]:=Module[{},
 Plot[Sin[x],{x,p["lowerLimit"],p["upperLimit"]}]
];
(* assoc["key"] is one of many equivalent ways to specify the data *)

Мы также можем легко реализовать проверки аргументов

fooWithChecks[p_?(NumericQ[#["lowerLimit"]] && NumericQ[#["upperLimit"]] &)] := Module[{}, 
 Plot[Sin[x], {x, p["lowerLimit"], p["upperLimit"]}]
];

В этом случае foo[plotLimits] и fooWithChecks[plotLimits] дают один и тот же график, потому что plotLimits имеет хорошие числовые значения. Но если мы определим

badPlotLimits = <|"lowerLimit" -> bad, "upperLimit" -> Pi|>;

затем оценка foo[badPlotLimits] дает ошибку

Plot::plln: Limiting value bad in {x,<|lowerLimit->bad,upperLimit->2 \[Pi]|>[lowerLimit],<|lowerLimit->bad,upperLimit->2 \[Pi]|>[upperLimit]} is not a machine-sized real number. >>
Plot[Sin[x], {x, <|"lowerLimit" -> bad, "upperLimit" -> 2 \[Pi]|>["lowerLimit"], <|"lowerLimit" -> bad, "upperLimit" -> 2 \[Pi]|>["upperLimit"]}]

но оценка fooWithChecks[badPlotLimits] просто остается невыполненной, поскольку аргумент не проходит проверку NumericalQ:

fooWithChecks[<|"lowerLimit" -> bad, "upperLimit" -> 2 \[Pi]|>]

Мне непонятно, почему вы спрашиваете о форме foo[from_?NumericQ, to_?NumericQ], а не foo[p_?(someCheckFunction)]. Ключевым преимуществом наличия структуры в первую очередь является то, что вы можете реорганизовать способ хранения структуры в памяти, скажем, поменяв местами порядок «lowerLimit» и «upperLimit», не переписывая ни одну из функций, которые ее используют ( так как они называют это p["lowerLimit"], а не p[[1]]). Эта возможность прерывается, если вы определяете foo таким образом, что при вызове foo аргументы выводятся по порядку. (Другими словами, вы не позволяете foo узнать о структуре.) Конечно, вы все равно можете это сделать, возможно, потому, что вы хотите использовать foo и для не-структур:

foo[from_?NumericQ, to_?NumericQ] :=
 Module[{}, Plot[Sin[x], {x, from, to}]];
foo[p] := foo[p["lowerLimit"], p["upperLimit"]];

Если вы хотите быть очень осторожным, вы можете использовать это:

foo[p_?(SubsetQ[Keys[#],{"lowerLimit", "upperLimit"}]&)] :=
 foo[p["lowerLimit"], p["upperLimit"]];

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

plotLimitType=<|"lowerLimit"->_NumericQ, "upperLimit"->_NumericQ|>

потому что ассоциации атомарны. См. здесь.

Кстати, обратите внимание, что такие ключи, как «lowerLimit», не обязательно заключать в кавычки. Использование этого стиля

plotLimits = <|lowerLimit -> -Pi, upperLimit -> Pi|>;

работает так же хорошо.

Для получения дополнительной информации см.

• Association
• DataSet (основан на Association)
• Руководства по Wolfram: начальное введение в наборы данных и Краткое введение для программистов.
• Вопросы Mathematica.SE: Как использовать ассоциации и Структурный эквивалент в Mathematica?
• Этот комментарий HackerNews.