I am looking for a name for the following function:
(f, a) => () => f(a)
Basically a function that returns a function which when called calls f with a.
Is there a common name for this function? maybe it can be described with some Ramda magic?
Edit to clarify:
What I'm looking for is similar to Ramda's partial,
partial(f, [a])
Except that partial is more like:
(f, a) => (b) => f(a, b)
I.e the b in the case of partial is unwanted.
That's a thunk.
Essentially, it's a reified computation that you can pass around and evaluate on demand. There are all sorts of reasons one might want to delay evaluation of an expression (it may be expensive, it may have time-sensitive side effects, etc.).
Doing const enThunk = f => a => () => f(a); lets you pass around f(a) without actually evaluating it until a later point in time.
I would call it prepared function with deferred calling.
The first part takes the function and argument and returns a function without calling the given function with argument. This is called later with explicit calling of the function.
I'd call that a special case of binding
If you have a function of two parameters, say f(x, y), then you can define g(y) = f(5, y). In that case, you bound the parameter x in f to the fixed point 5.
In JavaScript, this is likely referred to as bind. There might be a more specific name for this type of combinator in general (which is very similar to the apply combinator -> f => a => f(a)).
Simple to implement:
const bind = (f, a) => () => f(a)
it's a higher-order function.
A higher-order function is a function that takes at least one or more functions as an input or returns another function.
This definition satisfies the code:
(f, a) => () => f(a)
as it's essentially a function returning another function.
