function factorial(arg) {
return yCombinator((func) => {
return (n) => {
if (n <= 1) return n;
return n * func(--n)
}
})(arg)
}
function fibonacci(arg) {
return yCombinator((func) => {
return (n) => {
if (n <= 1) return n;
return func(n - 1) + func(n - 2)
}
})(arg)
}
function exponential(coef, exp) {
return yCombinator((func) => {
return (x, n) => {
if (n === 0) {
return 1
} else if (x === 0) {
return 0
}
return x * func(x, n - 1)
}
})(coef, exp)
}
The main difference in using built-in recursion versus the Y-Combinator programming style is the fact that the function is more of a wrapper for a call to the Y-Combinator function than anything else. The same result could be produced by writing the internal function passed to the Y-Combinator as a named function and simply calling the Y-Combinator with this new function as its argument every time you wished to use said function.
The only reason I choose to write the functions the way I did was for readability. Wrapping the Y-Combinator call make the calls to said function much closer to how developers are used to reading function calls, and also just makes more logical sense to read factorial(6) rather than yCombinator(factorial)(6) as would be necessary in our previously discussed possible style.
All source code for the Y-Combinator and this site can be found on GitHub