This library carries a suite of FunctionalInterfaces designed for general purpose use.
Functions are designed to extend the capabilities of java.util.Function, and expose the implementable method apply:
/** * Adds three numbers */ private Functions.Arity3<Integer, Integer, Integer, Integer> adder = (in1, in2, in3) -> in1 + in2 + in3; public static void main(String... args) { System.out.println("The sum of 5, 6, and 7 is " + adder.apply(5, 6, 7)); }
Computers are designed to provide efficiency, writing their output into a preallocated data container. This improves performance in loops, if the output can be discarded after each loop; reusing a single container can avoid many new calls. Computers expose the implementable method compute:
/** * Splits {@link String} {@code s} using delimiter {@code c}, * placing the results in {@link List} {@code outList} */ private Computers.Arity2<String, Character, List<String>> splitter = (s, c, outList) -> { outList.clear(); String[] strings = s.split(c); for (var str : strings) { outList.add(str); } }; public static void main(String... args) { var exampleStrings = new String[]{"foo:bar:baz", "foo:baz", "bar:baz"}; List<String> stringsContainingBar = new ArrayList<>(); List<String> container = new ArrayList<>(); for(var example : exampleStrings) { splitter.compute(example, ':', container); if(container.contains("bar")) { stringsContainingBar.add(example); } } }
Inplaces improve on the efficiency of Computers, when an input can be disposed of after the Inplace's completion. Inplaces overwrite a specified input with the output its exposed method mutate, improving performance by removing the need for a new call. Where Computers provide a preallocated output, Inplaces use their I/O object in the computation of the output.
Inplace are designated using two numbers (and are named ArityX_Y). The first number X indicates the number of inputs, and the second number Y indicates which parameter will be mutated. For example, Arity3_2 takes three arguments, and indicates that the second input will be mutated.
/** * Increments each number in the list */ private Inplaces.Arity2_2<Integer, List<Integer>> incrementer = (i, list) -> { for (var index = 0; index < list.size(); index++) { list.set(index, list.get(index) + i); } }; public static void main(String... args) { List<Integer> example = Arrays.asList(1, 1, 2, 3, 5, 8, 13, 21); incrementer.mutate(1, example); }
Consumers are designed (read: expected) to operate via side effects, and build off of the foundation of Consumer. Consumers expose the implementable method accept.
/** * Prints out the difference between a and b */ private Consumers.Arity2<Integer, Integer> printer = (a, b) -> { Integer diff = a - b; System.out.println("The difference between " + a + " and " + b + " is " + diff); }; public static void main(String... args) { printer.accept(3, 2); }