We present a library that adds curried higher order functions and tuple +types to Generic Java.
+ +Many of these ideas are taken from the functional programming +language Haskell.
+ +If we have a type for functions, we can define higher-order functions +such as map, filter, foldr, foldl, zipWith, curry, uncurry, flip. We can +provide partial application.
+ +In HOJ, functions are curried, that is, a n-argument function is +defined as a one-argument function that returns a (n-1)-argument +function. Unary (one-argument) functions are represented by the class +Fun<A,B>. Binary (two-argument) functions are represented +by the class Fun2<A,B,C>, which extends +Fun<A,Fun<B,C>>.
+ +Functions can be applied using their apply() method. If apply() is called +with fewer arguments that the arity of the function, a new function is +returned. There are several method declared +for functions. Examples include compose(), which composes to functions +to a new function, flip() which reverses the order in which a binary +function takes its arguments and map() which applies a function to all +elements of iterator, returning a new iterator.
+ +Basic functions such as Id (the identity function) and Const (a +constant function) are supplied.
+ +We often need pairs (or triples, quads etc.), for things like symbol table +entries and coordinates.
+ +The library contains classes such as Pair, the 2-tuple, and Triple, +the 3-tuple, (and Unit, the 0-tuple, and Cell, the 1-tuple). The tuple +classes also contain static functions such as zip (turns a tuple of +collections into a collection of tuples.)
+ +All tuple classes are immutable, as it simplifies concurrent +programming, and no compelling arguments for making them mutable has +been found.
+ +This is a simple grep-like utility that prints all lines +from System.in that matches a pattern given on the command line.
+ +
+import java.util.regex.*;
+
+import io.*;
+import fun.*;
+import static fun.Filter.*;
+import static fun.Compose.*;
+import static fun.TakeWhile.*;
+import static fun.Not.*;
+import static fun.Eq.*;
+
+
+/**
+ * Prints lines from System.in that that match a given regexp.
+ */
+public class Grep {
+ private static class Match extends Fun2<Matcher,String,Boolean> {
+ public Boolean apply(Matcher matcher, String s) {
+ return Boolean.valueOf(matcher.reset(s).matches());
+ }
+ }
+
+ public static void main(String[] args) {
+ Matcher matcher = Pattern.compile(".*"+args[0]+".*").matcher("");
+ new Println(System.out).map(
+ filter(new Match().apply(matcher),
+ takeWhile(compose(not(), eq(null)),
+ new ReadLine(System.in).repeat())));
+ }
+}
+
+
++Example 3.1 from "Pizza into Java: Translating theory into practise" +by Martin Odersky and Philip Walder, rewritten using HOJ. +
+ +
+import fun.Fun;
+
+class Radix {
+ int n = 0;
+ Fun<Character,Boolean> radix(final int r) {
+ return new Fun<Character,Boolean> () {
+ public Boolean apply(Character c) {
+ n++;
+ return new Boolean('0' <= c.charValue()
+ && c.charValue() < '0'+r);
+ }
+ };
+ }
+ String test() {
+ Fun<Character,Boolean> f = radix(8);
+ return f.apply(new Character('0'))+" "+f.apply(new Character('9'))+" "+n;
+ }
+}
+
+
+The original example (written in Pizza) is:
+ +
+class Radix {
+ int n = 0;
+ (char)->boolean radix(int r) {
+ return fun (char c)->boolean {
+ n++; return '0' <= c && c < '0'+r;
+ };
+ }
+ String test () {
+ (char)->boolean f = radix(8);
+ return f('0')+" "+f('9')+" "+n;
+ }
+}
+
+
++The library is intended to be used with the version of +Java programming language supported by the +Java 1.5.0 +release. +
+ +I gave a short presentation on HOJ +in the Topics in Computer Languages class.
+ ++JGA (Java Generic Algorithms), +http://jga.sourceforge.net/, +contains classes for unary and binary functions. The functions are not +curried and there are few higher order functions defined. +
+ ++Pizza into Java: Translating Theory into Practice, M. Odersky and P. Wadler, +1997. Available online at: +http://pizzacompiler.sourceforge.net/doc/pizza-language-spec.pdf. +The Pizza language extends Java to add genericity, higher-order functions +and algebraic types. The main difference between the higher-order functions +in Pizza and those in HOJ is that Pizza requires syntax extensions to Java, +whereas HOJ is a library. Also Pizza's funcions does not seem to be curried. +The genericity in Generic Java is based on that in Pizza. +
+ +Bjorn Bringert, bjorn@bringert.net.
+ +