So here’s my finding (warning : this is math rather than javascript …) :

We want to define function `f`

with a reference to itself. Said another way, we know a function `G`

such that `f = G(f)`

.

Let’s consider functions `h = g => G(U(g))`

, and `k = U(h)`

.

According to definition of `U`

, `k = h(h)`

. According to definition of `h`

applied to the outer `h`

, `k = G(U(h))`

. And according to definition of `k`

, `k = G(k)`

.

If we assume unicity of `f`

, we have `f = k`

.

So we should define operator `V = G => U(g => G(U(g)))`

, and that way, in order to define `f`

verifying `f = G(f)`

, we simply have `f = V(G)`

. We have transformed a recursive expression in a non-recursive one.

Example :

Lets assume this a standard case of recursion in javascript :

`const fibonacci = n => n < 2 ? n : fibonacci(n — 1) + fibonacci(n — 2)`

You would use the `V`

operator for the exact same use case in the following way :

`const fibonacci = V(fib => n => n < 2 ? n : fib(n — 1) + fib(n — 2))`

.

Which I find more readable than using the `U`

operator directly. Here, I don’t have to remember to apply it twice to itself.

What do you think?

Edit : `V`

is in actual fact the exact definition of the `Y`

combinator.