Is there a name for this kind of function?

Question

I'm a data analyst, not a software developer, and I often find myself writing a function like this (shown in Python syntax here):

def apply_many(arg, *funcs):
 return [func(arg) for func in funcs]

so I can do things like

from random import random
# generate 10 random numbers for demonstration
x = [random() for _ in range(10)]
def mean(x):
 return sum(x) / len(x)
result = apply_many(x, min, mean, max)

Which returns the minimum, mean, and maximum in x:

[0.022936866501094166, 0.3962645320243164, 0.7520986774090447]

That little apply_many function (with a few additional tweaks) routinely saves a lot of typing for me, and I also believe it makes for more readable code.

Is there some kind of accepted name for this thing? Is there a use for it in proper functional programming?

• Robert Harvey: It's simply an Apply function. See en.wikipedia.org/wiki/Apply

Answer 1

I don't know if there's an accepted named for it, but it is really just a form of map:

apply: ('a -> 'b) list -> 'a -> 'b list
apply functions arg = map (\f -> f arg) functions

That's not particularly interesting, but there you have it.

• shadowtalker: Indeed, and that's how I usually have it implemented in R (lapply) and Python (either map or a list comprehension as shown in the question). I suppose there isn't a name for it because it's not a very useful idiom in production code situations?
• Robert Harvey: It's a very useful idiom. Why do you insist on a fancier name than apply or map?
• gardenhead: Production code situations is not really relevant. Functions that are given common, widespread names are usually theoretically interesting: map, fold, accum, bind, etc. Honestly, I just don't think this code is interesting enough to warrant it's own name.
• shadowtalker: If you're interested, I've since realized that the term I was looking for is "juxtaposition". This of course is not really the same as what I described in the question, but I'm pretty sure it's what I had in mind at the time.

Answer 2

Since asking this question, I have seen a similar pattern referred to as "juxtaposition" or "juxt" (see e.g. https://clojuredocs.org/clojure.core/juxt).

A simple Python implementation would be:

def juxt(*funcs):
 def _f(x):
 return [f(x) for f in funcs]
 return _f
from random import random
data = [random() for _ in range(10)]
juxt(min, mean, max)(data)

This of course is not the same pattern, but I'm pretty sure this is what I had in mind when I originally asked the question.