Необязательные именованные аргументы без переноса их всех в OptionValue

Вот окончательная версия моего ответа, содержащая вклад Бретта Чемпиона.

ClearAll[def];
SetAttributes[def, HoldAll];
def[lhs : f_[args___] :> rhs_] /; !FreeQ[Unevaluated[lhs], OptionsPattern] :=
   With[{optionNames = Options[f][[All, 1]]},
     lhs := Block[optionNames, optionNames = OptionValue[optionNames]; rhs]];
def[lhs : f_[args___] :> rhs_] := lhs := rhs;

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

Clear[f, a, b, c, d];
Options[f] = {a -> c, b -> d};
(*The default values.*)
def[f[n_, OptionsPattern[]] :> (a + b)^n]

Теперь вы можете посмотреть на определение:

Global`f
f[n$_,OptionsPattern[]]:=Block[{a,b},{a,b}=OptionValue[{a,b}];(a+b)^n$]

f[n_,m_]:=m+n

Options[f]={a->c,b->d}

Мы можем проверить это прямо сейчас:

In[10]:= f[2]
Out[10]= (c+d)^2

In[11]:= f[2,a->e,b->q]
Out[11]= (e+q)^2

Модификации выполняются во время компиляции и довольно прозрачны. Хотя это решение позволяет сэкономить время на вводе w.r.t. У Бретта он определяет набор имен опций во время "компиляции", а у Бретта - во время выполнения. Поэтому он немного более хрупок, чем у Бретта: если вы добавите новую опцию в функцию после того, как она была определена с помощью def, вы должны очистить ее и перезапустить def. Однако на практике принято начинать с ClearAll и помещать все определения в одну часть (ячейку), так что это не кажется реальной проблемой. Кроме того, он не может работать со строковыми именами опций, но ваша исходная концепция также предполагает, что они являются символами. Кроме того, они не должны иметь глобальных значений, по крайней мере, во время выполнения def.

Почему бы просто не использовать что-то вроде:

Options[f] = {a->0, b->0};
f[args___] := (a+b) /. Flatten[{args, Options[f]}]

Для более сложного кода я бы, вероятно, использовал что-то вроде:

Options[f] = {a->0, b->0};
f[OptionsPattern[]] := Block[{a,b}, {a,b} = OptionValue[{a,b}]; a+b]

и используйте один вызов OptionValue, чтобы получить все значения сразу. (Основная причина в том, что это сокращает количество сообщений, если присутствуют неизвестные параметры.)

Обновите, чтобы программно сгенерировать переменные из списка параметров:

Options[f] = {a -> 0, b -> 0};
f[OptionsPattern[]] := 
  With[{names = Options[f][[All, 1]]}, 
    Block[names, names = OptionValue[names]; a + b]]

Вот какое-то ужасное решение:

Options[f] = {a->0, b->0};
f[OptionsPattern[]] := Module[{vars, tmp, ret},
  vars = Options[f][[All,1]];
  tmp = cat[vars];
  each[{var_, val_}, Transpose[{vars, OptionValue[Automatic,#]& /@ vars}],
    var = val];
  ret = 
    a + b;  (* finally! *)
  eval["ClearAll[", StringTake[tmp, {2,-2}], "]"];
  ret]

Он использует следующие удобные функции:

cat = StringJoin@@(ToString/@{##})&;        (* Like sprintf/strout in C/C++.  *)
eval = ToExpression[cat[##]]&;              (* Like eval in every other lang. *)
SetAttributes[each, HoldAll];               (* each[pattern, list, body]      *)
each[pat_, lst_, bod_] := ReleaseHold[      (*  converts pattern to body for  *)
  Hold[Cases[Evaluate@lst, pat:>bod];]];    (*   each element of list.        *)

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