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 mon 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.

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 mon 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.

• javascript
• functional-programming
• ramda.js

• FWIW I can’t imagine many places where this would be better than storing a in a variable and writing the arrow function in. – Ry- ♦ Commented Mar 9, 2018 at 21:35
• Amazing how much opinions you're getting! This is a primarily opinion-based question because you're going to get a lot of opinions based of experiences, Etc. Therefore, this question should be closed. – Ele Commented Mar 9, 2018 at 21:39
• 2 @Ele: Eh, it’s asking for a name that exists, not opinions on what it should be named. Just because a name probably doesn’t exist and people are answering with opinions on how to name it doesn’t necessarily mean it should be closed. – Ry- ♦ Commented Mar 9, 2018 at 21:40
• @Ryan look the answers, everyone is kicking something! – Ele Commented Mar 9, 2018 at 21:41
• I name this function call in many of my answers. deferred_call is also good – Mulan Commented Mar 10, 2018 at 6:15

5 Answers 5

That's a thunk.

Essentially, it's a reified putation 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.

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.

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.

In JavaScript, this is likely referred to as bind. There might be a more specific name for this type of binator in general (which is very similar to the apply binator -> 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.