# How should I define functions that distribute over Plus?

I have a linear function which also follows the chain rule (it is a derivation), so I defined it recursively, following a Wolfram tutorial (which I've misplaced) and other related answers:

fn[f_+g_] := fn[f] + fn[g]
fn[f_ g_] := fn[f] g + f fn[g]


Unfortunately, I have to run this on polynomials with thousands of terms, which inevitably leads to

$RecursionLimit::reclim: Recursion depth of 1024 exceeded.  I get around the issue in certain specific cases by using Distribute, which doesn't work well with the recursive chain rule. For example: (* fn[f_+g_]:= fn[f]+fn[g]; *) fn[f_ g_] := fn[f] g + f fn[g]; Distribute[fn[x (y + z)]] (* Out= (y + z) fn[x] + x fn[y + z] *)  I have also previously raised the $RecursionLimit but I feel requiring my definition of fn to work with infinitely many recursions is probably a bad idea (since I eventually run into larger and larger polynomials, I inevitably keep raising the recursion limit until I get tired of doing so and remove the limit altogether).

My question is: are there any problems with using

fn[f__Plus] := Plus @@ (fn /@ (List@@f))


as an alternative to the recursive rule? My question is a bit leading, but I do feel suspicious of the answer that Apply is always preferable to the recursive definition.

• If you are able to include code that generates an example polynomial that produces the recursion limit warning you may get better answers sooner, as it makes it less work to answer. – Mr.Wizard Mar 25 '15 at 8:44

ClearAll[fn]

• Here you are: x[] := Unique["x"]; poly = Times @@ Table[x[], {1024}] :) – Kuba Mar 25 '15 at 8:52