Y Combinator in Java

package ch.claude_martin;

import java.util.function.*;

/**
 * My Y Combinator can handle any reference type (primitives will be auto-boxed,
 * that's why I can use <code>long/Long</code> here). However, since I'm using
 * {@link UnaryOperator}, the recursive function must return the same type as
 * it's (second) argument. Factorial is a good example of this. Instead of long,
 * it could take a {@link java.math.BigInteger} and also return one.
 *
 */
public class YComb {
    /**
     * This is the <i>recursive</i> type of the function that will apply itself to
     * itself. This is how the recursion work.s A function needs itself as the first
     * parameter, so it then can call itself recursively.
     * <p>See this partial application in the code below:<br/>
     * <code>b -> b.apply(b)</code>
     */
    interface Fn2Op<T> extends Function<Fn2Op<T>, UnaryOperator<T>> {
    }

    /** Prints the factorial of <code>args[0]</code>.*/
    public static void main(String args[]) {
        final UnaryOperator<UnaryOperator<Long>> factorial =
                    f -> n -> (n == 0) ? 1L : n * f.apply(n - 1);
        System.out.println(apply(factorial, Long.parseLong(args[0])));
    }

    /**
     * Takes any <i>recursive</i> function (which takes itself and an argument) and
     * argument and returns the result. The argument and the return value are of the
     * same type <code>T</code>.
     *
     * @param <T> The type of <code>arg</code> and return value
     * @param fn The recursive function (in curried form)
     * @param arg The argument for the function
     * @return the result of applying <code>arg</code> to <code>fn</code>
     */
    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);
    }
}