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.
For a practical example, consider a fetch request. Now normally Promises start working as soon as they're constructed. But what if we want to retry the request if it fails? const response = fetch(someUrl); is done and on it's way but if we have const dataRequest = () => fetch(someUrl); the a retry is just calling the function again.