Looking for the name for an abstract class that models functions as objects

Question

In mathematics, adding two functions can be considered an operation in the space of functions. The result is another function.

I can model this by making functions an abstract class and implement all relevant operators for it. An object of that class can be assigned with basic functions (e.g. a constant) and the operators can be used to construct more complex functions. Those objects can be e.g. evaluated or differentiated

What would be a proper name for such an abstract class? Obviously function is a perfectly adequate term in the mathematical sense but ambiguous in programming.

I vaguely remember someone calling it functor but researching that term lead to something different.

Answer 1

You can take a look at what other people are doing:

• Java calls the package which contains the various function types java.util.function. Since Java does not support "generic overloading" (i.e. multiple generic types with the same name but different type parameters), it has separate types for functions with different parameter and return types, for example java.util.function.Function for a unary function, java.util.function.Consumer for a unary void function (i.e. a unary function which returns no value), java.util.function.Supplier for a nullary function, java.util.function.Predicate for a Boolean function as well as different arity, for example java.util.function.BiFunction for a binary function, java.util.function.BiConsumer for a binary void function (i.e. a binary function which returns no value), java.util.function.BiPredicate for a binary Boolean function, plus function types for primitives which cannot be abstracted over by generics, for example java.util.function.DoubleToIntFunction or java.util.function.DoubleToLongFunction.
• Scala also does not allow abstracting over the number of type parameters, and so has separate function types for each arity, which are called scala.FunctionN where N is the arity of the function, for example scala.Function0, scala.Function1, scala.Function2, etc.
• Kotlin calls it kotlin.Function
• Haskell calls the module which contains all the function manipulation Data.Function
• C# can abstract over the number of type parameters and does not have primitive types, but it cannot abstract over "void-ness", so it has two function types. It calls void functions System.Action and non-void functions System.Func.

I vaguely remember someone calling it functor but researching that term lead to something different.

Remember that a word means only what the person using the word wants it to mean. Nothing more, nothing less.

In this particular case, there are at least three distinct meanings in three distinct contexts, I am aware of:

• In mathematics, specifically category theory, a functor is (roughly speaking) "something which can be mapped over" or "computation with context". This is also the way the word is used in many programming language communities, for example in Haskell, Scala (e.g. cats and Scalaz), and Python.
• In ML, functor is the name given a module-level constructor which can construct modules out of other modules. This is similar to a type constructor (aka generic) which can construct types out of other types or a value constructor (aka function) which can construct values out of other values. In other words, in ML, a functor is to modules what a function is to values and a type constructor is to types.
• In C++, a functor is any object which has an operator(), i.e. any object which can be called as-if it were a function. While this is almost exclusively a C++ usage of the term, this is also the way the term is used in some other programming language communities. Confusingly, this includes communities which also use the term in the first sense, so you really have to look at each individual project and each individual person how they are using the term.

tl;dr summary: you can call it whatever you want, as long as you define what you mean.

Answer 2

It may look pretentious to propose an answer after Jörg's impressive one. But according to your comments, it seems that you're not interested in naming an object that can represent a black-box function ready to be executed, but you are looking at a type that supports symbolic representation of functions and operations to compose functions (f+g, f o g, ...).

In this case, the most general term would be lambda term. It is a concept borrowed from the lambda calculus, i.e. the theory at the foundation of computing. A lambda term can be a variable, a function of a variable (another lambda term associated with a variable, i.e. abstraction), or a function applied to an expression (application). As you can can see, you can operate on and combine lambda terms to construct more complex ones. A more casual alternative would be expression

If this terminology suits your needs (what matters here is the concept -- not the non-inutitive notation that lambda calculus uses) you could consider to the interpreter pattern for the implementation (unless you want to engage in some more complex term rewriting algorithms).

Answer 3

It depends on what you are trying to do. If you are creating a function to wrap other functions in a higher level of abstraction then you might call it a monad .