λ Tony’s blog λ

import java.io.Console;
 
interface Stringer {
  String convertString(String s);
}
 
class Interact {
  // interact :: (String -> String) -> IO ()
  static void interact(Stringer s) {
    final String line = System.console().readLine();
    final String c = s.convertString(line);
    System.out.println(c);
    interact(s);
  }
}

interface Lam<X, Y> {
  Y apply(X x);
}
 
// http://en.wikipedia.org/wiki/SKI_combinator_calculus
class SKI {
  public static <A, B, C> Lam<Lam<A, Lam<B, C>>, Lam<Lam<A, B>, Lam<A, C>>> s() {
    return new Lam<Lam<A, Lam<B, C>>, Lam<Lam<A, B>, Lam<A, C>>>() {
      public Lam<Lam<A, B>, Lam<A, C>> apply(final Lam<A, Lam<B, C>> f) {
        return new Lam<Lam<A, B>, Lam<A, C>>() {
          public Lam<A, C> apply(final Lam<A, B> g) {
            return new Lam<A, C>() {
              public C apply(final A a) {
                return f.apply(a).apply(g.apply(a));
              }
            };
          }
        };
      }
    };
  }
 
  public static <A, B> Lam<A, Lam<B, A>> k() {
    return new Lam<A, Lam<B, A>>() {
      public Lam<B, A> apply(final A a) {
        return new Lam<B, A>() {
          public A apply(final B b) {
            return a;
          }
        };
      }
    };
  }
 
  public static <A> Lam<A, A> i() {
    return SKI.<A, Lam<A, A>, A>s().apply(SKI.<A, Lam<A, A>>k()).apply(SKI.<A, A>k());
  }
}

// Simulate Higher-Order Functions.
// A lambda function is any implementation of this interface.
interface Lambda<X, Y> {
  Y apply(X x);
}
 
// What is a covariant functor?
// It is any implementation of this interface.
// All implementations must also satisfy:
//   * The law of identity
//   * The law of composition
// (but let's brush that to the side)
interface Functor<F> {
  <A, B> F<B> fmap(F<A> a, Lambda<A, B> f);
}
 
import java.util.LinkedList;
 
// Here is the functor for Java's LinkedList.
// It maps a function across each element of the list and returns a new one.
// (trust me, it satisfies the two laws).
class LinkedListFunctor implements Functor<LinkedList> {
  public <A, B> LinkedList<B> fmap(final LinkedList<A> a, final Lambda<A, B> f) {
    final LinkedList<B> r = new LinkedList<B>();
    for(final A x : a)
      r.append(f.apply(x));
    return r;
  }
}
 
// Here is a trivial Java data type.
// It happens to be a covariant functor.
// Let's witness its instance...
interface IntConverter<A> {
  A convert(int i);
}
 
// The Functor instance for the IntConverter.
class IntConverterFunctor implements Functor<IntConverter> {
  public <A, B> IntConverter<B> fmap(final IntConverter<A> a, final Lambda<A, B> f) {
    return new IntConverter<B>() {
      public B convert(final int i) {
        return f.apply(a.convert(i));
      }
    };
  }
}
 
// So why do we care?
// Because it prevents an enormous (*enormous*, *ENORMOUS!*)
// amount of otherwise needless repetition.
 
class FunctorX {
  // Gives rise to:
  // LinkedList<Lambda<A, B>> => A => LinkedList<B>
  // IntConverter<Lambda<A, B>> => A => IntConverter<B>
  // ...
  // F<Lambda<A, B>> => A => F<B> (for many values of F)
  public static <A, B, F> F<B> fapply(final Functor<F> f, final F<Lambda<A, B>> lam, final A a) {
    return f.fmap(lam, new Lambda<Lambda<A, B>, B>() {
      public B apply(final Lambda<A, B> z) {
        return z.apply(a);
      }
    });
  }
 
  // ... etcetra.
}
 
// It turns a linear amount of code into a constant amount of code.
// Similarly a sort function that runs on lists of
// any type (provided a comparator) alleviates the need for linear
// amounts of code (a sort function for each possible list element type).

class C {
  static String i() {
    throw new Error("boo!");
  }
 
  static <A> int f(A a) {
    return 3;
  }
 
  public static void main(String[] args) {
    int k = f(i());
    System.out.println(k);
  }
}

i = error "boo!"
 
f a = 3
 
main = let k = f i
       in print k

interface Pair<A, B> {
  A first();
  B second();
}
 
class Pairs {
  public static <A, B> Pair<A, B> pair(final A a, final B b) {
    return new Pair<A, B>() {
      public A first() { return a; }
      public B second() { return b; }
    };
  }
}
 
interface State<S, A> {
  Pair<S, A> run(S s);
}
 
interface Function<X, Y> {
  Y apply(X x);
}
 
class States {
  // State<S, _> is a covariant functor
  public static <S, A, B> State<S, B> map(final State<S, A> s, final Function<A, B> f) {
    return new State<S, B>() {
      public Pair<S, B> run(final S k) {
        final Pair<S, A> p = s.run(k);
        return Pairs.pair(p.first(), f.apply(p.second()));
      }
    };
  }
 
  // // State<S, _> is a monad
  public static <S, A, B> State<S, B> bind(final State<S, A> s, final Function<A, State<S, B>> f) {
    return new State<S, B>() {
      public Pair<S, B> run(final S k) {
        final Pair<S, A> p = s.run(k);
        return f.apply(p.second()).run(p.first());
      }
    };
  }
}