all tasks

Task/Y-combinator/Java/y-combinator-4.java

@@ -0,0 +1,147 @@
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+
+@FunctionalInterface
+interface VarargFunction<INPUT, OUTPUT> {
+  public OUTPUT apply(List<? extends INPUT> input);
+
+  public default OUTPUT apply() {
+    return apply(Collections.emptyList());
+  }
+
+  public default OUTPUT apply(INPUT input) {
+    return apply(Collections.singletonList(input));
+  }
+
+  public default OUTPUT apply(INPUT input, INPUT input2) {
+    return apply(Arrays.asList(input, input2));
+  }
+
+  public default OUTPUT apply(INPUT input, INPUT input2, INPUT input3) {
+    return apply(Arrays.asList(input, input2, input3));
+  }
+
+  public default OUTPUT apply(Class<INPUT> type, Object... input) {
+    List<INPUT> i = Collections.checkedList(new ArrayList<>(), type);
+    for (Object object : input) {
+      i.add(type.cast(object));
+    }
+    return apply(i);
+  }
+
+  public default <POST_OUTPUT> VarargFunction<INPUT, POST_OUTPUT> compose(
+      VarargFunction<OUTPUT, POST_OUTPUT> after) {
+    return input -> after.apply(apply(input));
+  }
+
+  public default Function<INPUT, OUTPUT> toFunction() {
+    return input -> apply(input);
+  }
+
+  public default BiFunction<INPUT, INPUT, OUTPUT> toBiFunction() {
+    return (input, input2) -> apply(input, input2);
+  }
+
+  public default <PRE_INPUT> VarargFunction<PRE_INPUT, OUTPUT> transformArguments(Function<PRE_INPUT, INPUT> transformer) {
+    return input -> apply(input.parallelStream().map(transformer).collect(Collectors.toList()));
+  }
+}
+
+@FunctionalInterface
+interface SelfApplicable<OUTPUT> {
+  OUTPUT apply(SelfApplicable<OUTPUT> input);
+}
+
+class Utils {
+  public static <T> T input( List<T> input, int index) {
+    return input.size() > index ? input.get(index) : null;
+  }
+
+  /* Based on https://gist.github.com/aruld/3965968/#comment-604392 */
+
+  public static <INPUT, OUTPUT> SelfApplicable<Function<Function<Function<INPUT, OUTPUT>, Function<INPUT, OUTPUT>>, Function<INPUT, OUTPUT>>> y(Class<INPUT> input, Class<OUTPUT> output) {
+    return y -> f -> x -> f.apply(y.apply(y).apply(f)).apply(x);
+  }
+
+  public static <INPUT, OUTPUT> Function<Function<Function<INPUT, OUTPUT>, Function<INPUT, OUTPUT>>, Function<INPUT, OUTPUT>> fix(Class<INPUT> input, Class<OUTPUT> output) {
+    return y(input, output).apply(y(input, output));
+  }
+
+  public static <INPUT, OUTPUT> SelfApplicable<Function<Function<VarargFunction<INPUT, OUTPUT>, VarargFunction<INPUT, OUTPUT>>, VarargFunction<INPUT, OUTPUT>>> yVararg(Class<INPUT> input, Class<OUTPUT> output) {
+    return y -> f -> x -> f.apply(y.apply(y).apply(f)).apply(x);
+  }
+
+  public static <INPUT, OUTPUT> Function<Function<VarargFunction<INPUT, OUTPUT>, VarargFunction<INPUT, OUTPUT>>, VarargFunction<INPUT, OUTPUT>> fixVararg(Class<INPUT> input, Class<OUTPUT> output) {
+    return yVararg(input, output).apply(yVararg(input, output));
+  }
+
+  public static <INPUT, OUTPUT> VarargFunction<INPUT, OUTPUT> toVarargFunction(Function<INPUT, OUTPUT> function) {
+    return input -> function.apply(Utils.input(input, 0));
+  }
+
+  public static <INPUT, OUTPUT> VarargFunction<INPUT, OUTPUT> toVarargFunction(BiFunction<INPUT, INPUT, OUTPUT> function) {
+    return input -> function.apply(Utils.input(input, 0), Utils.input(input, 1));
+  }
+}
+
+public class Y {
+  public static final BigInteger TWO = BigInteger.ONE.add(BigInteger.ONE);
+
+  public static final Function<Number, BigInteger> toBigInteger = ((Function<Number, Long>) Number::longValue).compose(BigInteger::valueOf);
+
+  public static void main(String[] args) {
+    VarargFunction<Number, Number> fibonacci = Utils.fixVararg(Number.class, Number.class).apply(
+      f -> Utils.toVarargFunction(
+        toBigInteger.compose(
+          n -> (n.compareTo(TWO) <= 0) ? 1
+            : new BigInteger(f.apply(n.subtract(BigInteger.ONE)).toString())
+              .add(new BigInteger(f.apply(n.subtract(TWO)).toString()))
+        )
+      )
+    );
+
+    VarargFunction<Number, Number> factorial = Utils.fixVararg(Number.class, Number.class).apply(
+      f -> Utils.toVarargFunction(
+        toBigInteger.compose(
+          n -> (n.compareTo(BigInteger.ONE) <= 0) ? 1
+          : n.multiply(new BigInteger(f.apply(n.subtract(BigInteger.ONE)).toString()))
+        )
+      )
+    );
+
+    VarargFunction<Number, Number> ackermann = Utils.fixVararg(Number.class, Number.class).apply(
+      f -> Utils.toVarargFunction(
+        (BigInteger m, BigInteger n) -> m.equals(BigInteger.ZERO) ? n.add(BigInteger.ONE)
+          : f.apply(m.subtract(BigInteger.ONE),
+            n.equals(BigInteger.ZERO)
+              ? BigInteger.ONE
+                : f.apply(m, n.subtract(BigInteger.ONE)))
+      ).transformArguments(toBigInteger)
+    );
+
+    Map<String, VarargFunction<Number, Number>> functions = new HashMap<>();
+    functions.put("fibonacci", fibonacci);
+    functions.put("factorial", factorial);
+    functions.put("ackermann", ackermann);
+
+    Map<VarargFunction<Number, Number>, List<Number>> arguments = new HashMap<>();
+    arguments.put(functions.get("fibonacci"), Arrays.asList(20));
+    arguments.put(functions.get("factorial"), Arrays.asList(10));
+    arguments.put(functions.get("ackermann"), Arrays.asList(3, 2));
+
+    functions.entrySet().parallelStream().map(
+      entry ->
+        entry.getKey() + arguments.get(entry.getValue()) + " = "
+          + entry.getValue().apply(arguments.get(entry.getValue()))
+    ).forEach(System.out::println);
+  }
+}