What should a member function be called that applies an argument function to the object?

Question

Apply is a fitting name for a member function of a function-type class that applies the function to the given arguments:

class Addition {
   int apply(int a, int b) {
      return a + b;
   }
}

But what about the opposite, when the class that a function is applied to has a method that applies a given function to itself?

class FktArg {
   Object whatShouldIBeNamed(Function<FktArg> fkt) {
      return fkt.apply(this);
   }
}

What is the naming convention here?

Answer 1

It's always nice to see people who really care about good naming.

I think map would be a well understood name for this method:

// Java 1.8 example
// `T` is the type of `this` Object
public <R> R map(Function<? super T, ? extends R> func) {
    return func.apply(this);
}

Wikipedia says:

In many programming languages, "map" is the name of a higher-order function that applies a given function to each element of a functor...

Usually the functor is a collection of elements but I believe that an individual element as the functor is still very understandable.

Sticking with the Java example, this would be similar to map in the Java Stream API, but since you're only mapping one Object, you just return R instead of Stream<R>

java.util.stream.Stream:
<R> Stream<R> map(Function<? super T, ? extends R> mapper)

Returns a stream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Type Parameters: <R> The element type of the new stream
Parameters:mapper - a non-interfering, stateless function to apply to each element
Returns:the new stream

Answer 2

I think I'd possibly go with the word "apply" for both contexts.

In the first case, the operands are provided as method arguments whilst the operation is parameterised via the object itself (presumably subtraction etc. would be handled by the programmer using the method of a different object).

In the second case it is the operation which is parameterised, whereas the operand(s) are implied by the containing object.

Either way, it's equally an application of operations to operands. And to that extent, it may imply poor modelling - what may be missing here is an operator or applicator class with an apply method, that is, a class which generically applies operations to operands, both of which are provided as parameters. Operations then become functions instead of classes, and operands become records instead of classes, both of which are passed as parameters to an apply method.

It's like the old question about whether it should be the sending or receiving Account object which contains the TransferMoney method - in fact it's neither, it's the Journal object which transfers money, and it takes at least two Accounts as parameters.

Alternatively, it may be a sign that there is confusion or inconsistency in whether it is the operation or the operand which is treated as the active participant. It makes natural sense to say that an addition takes two numbers and sums them. It makes less natural sense to say two numbers take an addition and sum themselves, even less again to say that a number takes an addition and another number and sums itself.

Answer 3

Its similar to the pipe forward operator in F# https://theburningmonk.com/2011/09/fsharp-pipe-forward-and-pipe-backward/ so I'd go for pipe

this is also essentially the powershell pipe operator, which obviously is realted to unix pipe (though in unix land it's strings only)

other less well know places I've found this

elm has a pipe operator https://dennisreimann.de/articles/elm-functions.html

elixir https://elixirschool.com/en/lessons/basics/pipe-operator/

OCaml (admitedly this is highly related to F#) has a pipline operator https://www.cs.cornell.edu/courses/cs3110/2019sp/textbook/hop/pipelining.html

R (but not in the base language) https://magrittr.tidyverse.org/reference/pipe.html

Javascript (but experimental) https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Pipeline_operator

RFC to add a pipe operator to PHP https://wiki.php.net/rfc/pipe-operator

Overall I think the consensus is that a flipped function application is a pipe

for completness the only language I can find that has this and doesn't call it pipe is kotlin and thats becuase you can emulate this with existing run or let