How to write complex function definitions at run time?

Question

(Posting as a self-answered question to share a technique I discovered)

In a certain project, I have many function definitions in which all parameters should be optional and come with default values. A simplified example is the following:

ClearAll[sampleFunction];
Options[sampleFunction] = {
   "a" -> 1000,
   "b" -> {},
   "c" -> 42};
sampleFunction[OptionsPattern[]] :=
  Module[{
    a = OptionValue["a"],
    b = OptionValue["b"],
    c = OptionValue["c"]},
   Append[b, a + c]];

sampleFunction[]

{1042}

sampleFunction["b" -> {1, 2, 3}, "a" -> -38]

{1, 2, 3, 4}

The problem with this pattern is there is a lot of repetitive boilerplate, increasing the risk of typographical errors and fatigue for readers and writers of the code (imagine that the option names are long and complicated and that there are dozens of them, not just three as in the example).

I'd like to have a syntax like the following,

functionator[
  sampleFunction, 
  <|"a" -> 1000, "b" -> {}, "c" -> 42|>, 
  Append[b, a + c]]

that minimally captures the essential features of the definition without undue repetition.

functionator must transform its second argument, an Association of option names and default values, into a Module, but it's not straightforward. For instance, the following attempt just produces syntax errors in the Module specification because things are all being evaluated at inappropriate times:

ClearAll[functionator];
SetAttributes[functionator, HoldAllComplete];
functionator[nym_, args_, body_] :=
  With[{
    keys = Keys[args],
    vars = Symbol /@ Keys[args],
    vals = Values[args]},
   ClearAll[nym];
   Options[nym] = Normal[args];
   nym[OptionsPattern[]] :=
    Module[
     MapThread[
      {var, key} \[Function] var = OptionValue[key],
      {vars, keys}
      ], body]];

functionator[
 sampleFunction,
 <|"a" -> 1000, "b" -> {}, "c" -> 42|>,
 Append[b, a + c]]

sampleFunction[]

During evaluation of In[317]:= Module::lvlist: Local variable specification 
MapThread[Function[{var$,key$},var$=OptionValue[sampleFunction,{},key$]],
{{a,b,c},Keys[Association[a->1000,b->{},c->42]]}] is not a List. >>

Module[
 MapThread[
  Function[{var$, key$}, 
   var$ = OptionValue[sampleFunction, {}, key$]], {{a, b, c}, 
   Keys[Association["a" -> 1000, "b" -> {}, "c" -> 42]]}], 
 Append[b, a + c]]

Trying to sort this out with various Hold..., Release, and Evaluate combinations was exhausting and not converging.

There must be a better way.

Answer 1

This question is closely related to:

• Best practice of passing a large number of parameters to functions

In my answer there I gave a couple of abstractions to simplify definitions of the type you describe. I shall reiterate my approach with adjustment for your syntax.

Code using listWith

SetAttributes[{listWith, defWithOpts2}, HoldAll]

listWith[(set : Set | SetDelayed)[L_, R_], body_] := 
 set @@@ Thread[Hold @@@ {L, R}, Hold] /. _[x__] :> With[{x}, body]

defWithOpts2[h_Symbol, asc_Association, RHS_] :=
  With[{keys = Keys[asc]},
    With[{syms = Join @@ ToHeldExpression[keys]},
      Options[h] = Normal[asc];
      h[OptionsPattern[]] := listWith[syms = OptionValue[keys], RHS]
    ]
  ]

Example:

defWithOpts2[
  sampleFunction,
  <|"a" -> 1000, "b" -> {}, "c" -> 42|>,
  Append[b, a + c]
]

sampleFunction["b" -> foo[bar], "a" -> 17]

foo[bar, 59]

This generates a definition that is reliant upon listWith:

sampleFunction[OptionsPattern[]] :=
  listWith[Hold[a, b, c] = OptionValue[{"a", "b", "c"}], Append[b, a + c]]

I actually prefer this as I think the syntax is cleaner, e.g. there is only one OptionValue call.

Code without listWith

If you dislike the listWith dependency here is the function with the expansion included:

SetAttributes[defWithOpts3, HoldAll]

defWithOpts3[h_Symbol, asc_Association, RHS_] :=
  With[{keys = Keys[asc]},
    With[{syms = Join @@ ToHeldExpression[keys]},
      Options[h] = Normal[asc];
      Inner[Set, syms, OptionValue /@ Hold @@ keys, Hold] /. _[x__] :>
       (h[OptionsPattern[]] := With[{x}, RHS])
    ]
  ]

The definition it creates:

sampleFunction[OptionsPattern[]] := 
 With[{a = OptionValue["a"], b = OptionValue["b"], c = OptionValue["c"]}, 
  Append[b, a + c]]

Answer 2

The new cluster of Inactive, Inactivate, and Activate heads in 10.0+ were designed for exactly this task. So far as I can tell, they give approximately the same level of functionality as macros in Common Lisp.

Consider the following preliminary step that exhibits the desired rewrite in inactive form, just to show the technique at work

ClearAll[functionatorExpander];
SetAttributes[functionatorExpander, HoldAllComplete];
functionatorExpander[nym_, args_, body_] :=
  With[{
    vars = Symbol /@ Keys[args],
    vals = Values[args]},
   ClearAll[nym];
   Options[nym] = Normal[args];
   Inactive[SetDelayed][nym[OptionsPattern[]],
    Inactive[Module][
     MapThread[
      {var, key} \[Function]
       Inactive[Set][
        var,
        OptionValue[key]],
      {vars, Keys[args]}
      ], Inactivate[body]]]];

functionatorExpander[
  sampleFunction,
  <|"a" -> 1000, "b" -> {}, "c" -> 42|>,
  Append[b, a + c]] // StandardForm

Here is another version that activates the generated code, with a couple of unit tests

ClearAll[functionator];
SetAttributes[functionator, HoldAllComplete];
functionator[nym_, args_, body_] :=
  With[{
    vars = Symbol /@ Keys[args],
    vals = Values[args]},
   ClearAll[nym];
   Options[nym] = Normal[args];
   SetDelayed[nym[OptionsPattern[]],
    Activate[
     Inactive[Module][
      MapThread[
       {var, key} \[Function]
        Inactive[Set][
         var,
         OptionValue[key]],
       {vars, Keys[args]}
       ], Inactivate[body]]]]];

functionator[
 sampleFunction,
 <|"a" -> 1000, "b" -> {}, "c" -> 42|>,
 Append[b, a + c]]

sampleFunction[]

{1042}

sampleFunction["b" -> {1, 2, 3}, "a" -> -38]

{1, 2, 3, 4}