Vocabulary: Should I call this apply or map? [closed]

Question

So, I'm tasked with organizing the code and building a library with all the common code among our products.

One thing that seems to happen all the time and I wanted to abstract is posted below in pseudocode, and I don't know how to call it (different products have different domain specific implementations and names for it)

list function idk_what_to_name_it ( list list_of_callbacks, value common_parameter ): 
  list list_of_results = new list
  for_each(callback in list_of_callbacks)
    list_of_results.push(callback(common_parameter))
  end for_each
  return list_of_results
end function

Would you call this specific construct a

list ListOfCallbacks.Map( value value_to_map) 

method or would it better be

value Value.apply(list list_of_callbacks)

I'm really curious about this kind of thing. Is there a standard guide for this stuff?

Answer 1

This is a map. In haskell it would be written as

map ($ param) listOfFunctions

this would take each function and execute it with the single param, returning a list of the results.

I don't recognize the language you used but I think something like this makes sense

list function map ( callback functionToMap, list list_of_callbacks ): 
  list list_of_results = new list
  for_each(callback in list_of_callbacks)
    list_of_results.push(functionToMap(callback))
  end for_each
  return list_of_results
end function

Then you would use it as:

value function execute_with_parameter( callback function_to_execute ):
  return function_to_execute(whatever_parameter_you_want)
end function

map(execute_with_parameter, list_of_callbacks)

Mapping over a list of items means using a normal function to map over it, mapping over a list of functions means using a higher order function to map over it, but it's a map all the same.

Answer 2

I don't know if that is the standard name (or if that is what you would really like to call it), but in Clojure, function that does this is called juxt (short of juxtaposition)

Usage: (juxt f)
       (juxt f g)
       (juxt f g h)
       (juxt f g h & fs)
Takes a set of functions and returns a fn that is the juxtaposition
of those fns.  The returned fn takes a variable number of args, and
returns a vector containing the result of applying each fn to the
args (left-to-right).
((juxt a b c) x) => [(a x) (b x) (c x)]

Source: http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/juxt

Your example is a special case of juxt with exactly one parameter (and type related stuff you mentioned, due to the implementation details).

Answer 3

It doesn't follow the classic meanings for either 'map' or 'apply'. Map calls the same function on each element from a list, and returns a list of the results. 'Apply' calls a function passing the elements of a list as function arguments. Your function is closer to 'map', but since it passes the same argument to a list of functions, instead of repeatedly calling a single function, I would give it a different name.

Answer 4

You could call it an n-dimensional pointwise Cartesian product of functions. However, that doesn't make for a short name, and might require explanation...

Answer 5

To my mind, the word "map" implies some kind of association (e.g. a 'dictionary'), although there doesn't appear to be any association or pairing of data happening in your algorithm.

The result of your function is a generated list of values, so I would suggest that it's important that the name of your function puts a certain amount of emphasis on the end result and/or any side-effects the algorithm may have on state (It doesn't appear to have side-effects so more emphasis on the result/output).

e.g. The C++ standard library is equipped with some vaguely similar algorithms which contain the word generate - their purpose is to generate multiple data elements based on the input arguments.

Answer 6

There is no real standard for this, in fact not even a common convention. You may want to browse through APIs of programming languages and toolkits that do a lot of list juggling: Ruby, Python, Linq, Matlab, Maple, C++ STL, ... Take a look and you'll see that each program/lib has its own conventions.

In fact the mentioned languages/libs even have contradicting naming conventions:

Ruby:

doubled = [1,2,3].map{|x| 2*x}

Linq:

var doubled = new int[] { 1, 2, 3}.Select(s => 2 * x);

(In Ruby select filters items from a list.)

Maybe you want to call your function applyMaps? This is what Maple does:

map(apply, [sin, cos, tan], Pi)

produces:

[0, -1, 0]

Answer 7

I'd call it fire_callbacks, call_callbacks, apply_callbacks, or something like that.

I've usually had such a method as part of a signal or observable object.