content: import java.util.Arrays;
  import java.util.function.BiFunction;
  import java.util.function.Function;
  import java.util.function.IntUnaryOperator;
  import java.util.function.UnaryOperator;
  import java.util.stream.Stream;
  
  @FunctionalInterface
  public interface PartialApplication<INPUT1, INPUT2, OUTPUT> extends BiFunction<INPUT1, INPUT2, OUTPUT> {
    // Original method fs(f, s).
    public static int[] fs(IntUnaryOperator f, int[] s) {
      return Arrays.stream(s)
        .parallel()
        .map(f::applyAsInt)
        .toArray()
      ;
    }
  
    // Currying method f.apply(a).apply(b),
    // in lieu of f.apply(a, b),
    // necessary for partial application.
    public default Function<INPUT2, OUTPUT> apply(INPUT1 input1) {
      return input2 -> apply(input1, input2);
    }
  
    // Original method fs turned into a partially-applicable function.
    public static final PartialApplication<IntUnaryOperator, int[], int[]> fs = PartialApplication::fs;
  
    public static final IntUnaryOperator f1 = i -> i + i;
  
    public static final IntUnaryOperator f2 = i -> i * i;
  
    public static final UnaryOperator<int[]> fsf1 = fs.apply(f1)::apply; // Partial application.
  
    public static final UnaryOperator<int[]> fsf2 = fs.apply(f2)::apply;
  
    public static void main(String... args) {
      int[][] sequences = {
        {0, 1, 2, 3},
        {2, 4, 6, 8},
      };
  
      Arrays.stream(sequences)
        .parallel()
        .map(array ->
          Stream.of(
            array,
            fsf1.apply(array),
            fsf2.apply(array)
          )
            .parallel()
            .map(Arrays::toString)
            .toArray()
        )
        .map(array ->
          String.format(
            String.join("\n",
              "array: %s",
              "  fsf1(array): %s",
              "  fsf2(array): %s"
            ),
            array
          )
        )
        .forEachOrdered(System.out::println)
      ;
    }
  }
  