The Y Combinator allows us to use recursion without actually using the recursion that Java already has. And Java 8 actually doesn’t support recursion in lambdas. So this is one way of solving the problem. The simpler one would be to use a recursive Java method and then use a method reference to it (as in `MyMathsFunctions::factorial`

). This is to show that Haskell Curry was right and we can do it with nothing but lambda expressions. Since Java is strongly typed I also need an interface, which references itself in the type declaration. This is necessary because at some point we need to apply a function to itself.

There are enough wiki and blog pages and articles on this. Even videos. So I won’t explain it in details. It’s nothing new, just written in Java 8.

## Code on Pastebin

**The full Code is here:** https://pastebin.com/M2RmRqdU

```
private static <T> T apply(UnaryOperator<UnaryOperator<T>> fn, T arg) {
return ((Function<UnaryOperator<UnaryOperator<T>>, UnaryOperator<T>>)
a -> ((Fn2Op<T>) b -> b.apply(b))
.apply(
c -> a.apply(
x -> c.apply(c).apply(x)
)
)).apply(fn).apply(arg);
}
```