Using Association[] in an Immediate Function

Question

I have an Association[] which is the result of an intensive computation. Its values include the variable x and I would like to turn the entire Association[] into a set of Functions.

I could use a Delayed Definition (Reference) using the := function (SetDelayed). However, this would redo the initial computation every time, which is inefficient. I prefer using an Immediate Definition using = for the Function. However, that does not seem to work.

The following Mathematica code illustrates the problem:

f1[x_]=Association["linear"->x, "square"->x^2];
f1[3]["square"] (* x^2 *)
f2[x_]:=Association["linear"->x, "square"->x^2]
f2[3]["square"] (* 9 *)

Function f1 does not produce the desired result, whereas f2 does. How can I obtain the desired result? If possible, please explain the underlying theory, such that I will be able to tackle such problems myself in the future.

Answer 1

I think the "why" has already been covered quite well by the previous answers, but the "how" could probably be expanded on a bit. If you want to be able to use syntax like f1[3]["square"] you could use SubValues instead:

f3[x_]["linear"] = x;
f3[x_]["square"] = x^2;

In[13]:= f3[2]["square"]

Out[13]= 4

Or just do f3[x_, "linear"] = x;, which is probably even easier. If you insist on having everything inside of an Association, I personally think the best way is to build an Association of Functions. I'm going to assume you start with some big expression with xes in it, so you need to convert that to a function of x:

In[21]:= f4 = Function[{x}, #] & /@ <|"linear" -> x, "square" -> x^2|>

Out[21]= <|"linear" -> Function[{x}, x], "square" -> Function[{x}, x^2]|>


In[22]:= f4["square"][3]

Out[22]= 9

As you can see, you now need to first specify the key before the value. The added bonus here is that (for purely numeric functions) you can substitute Function with Compile to get an extra boost in evaluation speed.

I'd also like to add that there's a good reason why you wouldn't want to do this in the way the OP asked for. If the syntax f1[3]["linear"] actually worked, it would still compute both 3 and 3^2 (and everything else you might have stored in the association) even though you only need the first key. Sure, the squaring might not be super intensive, but it's still extra work you're throwing away right afterwards. Both of the methods I proposed here avoid this issue.

Answer 2

The problem you are encountering is related to the fact that Association objects are atomic:

Association["key"->x] //AtomQ

True

Since they are atomic, their contents can not be bound to a pattern variable. For a different example, consider:

(f[x_] = Graph[{1->2}, EdgeWeight->{x}, EdgeLabels->"EdgeWeight"]) //InputForm

Graph[{1, 2}, {DirectedEdge[1, 2]}, {EdgeLabels -> {"EdgeWeight"}, EdgeWeight -> {x}}]

f[1] //InputForm

Graph[{1, 2}, {DirectedEdge[1, 2]}, {EdgeLabels -> {"EdgeWeight"}, EdgeWeight -> {x}}]

The SetDelayed variant works because the Association has not evaluated, so it is not yet atomic.

Answer 3

Pattern-based function definition works by specifying rewrite rules. These rules can be seen with the DownValues command. When you use Set (=) the right-hand side is immediately evaluated. In this case, the difference between your two functions is the difference in whether or not the right-hand side was evaluated in producing the rewrite rule. So here is an equivalent way to define these two functions:

ClearAll[f1,f2,x]
DownValues[f1]= List[RuleDelayed[HoldPattern[f1[Pattern[x,Blank[]]]],Evaluate@Association[Rule["key",x]]]]
DownValues[f2]= List[RuleDelayed[HoldPattern[f2[Pattern[x,Blank[]]]],Association[Rule["key",x]]]]
f1[123]  (* <|"key" -> x|> *)
f2[123]  (* <|"key" -> 123|> *)

As you can see, the only difference is whether or not we forced evaluation of the association.