the Programming Pantheon

data Maybe a = Just a
             | Nothing

trait Option[A] {}
sealed case class Some[A](val a:A) {}
case object None {}

interface Maybe<A> {}
final class Some<A> implements Maybe<A> {
    private final A a;
    public Some(final A a) { this.a = a; }
    public A get()         { return a;   }
}
final class None implements Maybe<Object> {}

integerDivision :: Integer -> Integer -> Maybe Integer

def integerDivision(a:Int, b:Int):Option[Int]

public Maybe<Integer> integerDivision(Integer a, Integer b)

integerDivide 10 2 case of
   Just a -> a
   Nothing -> 0

integerDivide(10, 2) match {
  case Some(a) => a
  case None => 0
}

integerDivide(10, 2).getOrElse(0)

Maybe<Integer> result = integerDivide(10, 2);
if (result instanceof Some<Integer>) {
    return ((Some<Integer>)result).get();
} else {
    return 0;
}

public interface MaybeMap<K, V> extends Map<K, Maybe<V>> {
    public Maybe<V> putRaw(V value);
    public void putRawAll(Map<K, V> m);
}

public class MaybeMapWrapper<K, V> implements MaybeMap<K, V> {
    private final Map<K, Maybe<V>> map;
    public MaybeMapWrapper(final Map<K, V> m) {
        map = new HashMap<K, Maybe<V>>(m.size());
        putRawAll(m);
    }
    public Maybe<V> putRaw(K key, V value) {
        return map.put(key, new Some<V>(value));
    }
    public void putRawAll(Map<K, V> m) {
        for(Map.Entry<K, V> entry : m.entrySet()) {
            map.put(entry.getKey(), new Some<V>(entry.getValue()));
        }
    }
    public Maybe<V> get(Object key) {
        if (map.containsKey(key)) {
            return map.get(key);
        }
        return new None();
    }
    public Maybe<V> put(K key, Maybe<V> value) {
        if (value == null) {
            value = (Maybe<V>)new None();
        }
        return map.put(key, value);
    }
    // The rest simply delegates to map
}

    public Maybe<V> get(Object key) {
        Maybe<V> v = map.get(key);
        if (v == null) {
            return new None();
        }
        return v;
    }

public interface Maybe<A> {
    public boolean isNone();
    public <E extends A> A getOrElse(final E otherwise);
}
public class Some<A> implements Maybe<A> {
    private final A a;
    public Some(final A a)  { this.a = a;   }
    public boolean isNone() { return false; }
    public <E extends A> A getOrElse(final E otherwise) { return a; }
    public A get() { return a; }
}
public class None implements Maybe<Object> {
    public boolean isNone() { return true; }
    public <E extends Object> E getOrElse(final E otherwise) { return otherwise; }
}

public abstract class Maybe<A> {
    Maybe(){}
    public abstract boolean isNone();
    public <E extends A> getOrElse(final E otherwise)	{	return a;	}
}

public final class Some<A> extends Maybe<A> {
    private final A a;
    public Some(final A a) { this.a = a; }
    @Override public final boolean isNone() { return false; }
    @Override public final <E extends A> A getOrElse(final E otherwise) { return a; }
    public final A get() { return a; }
}

public final class None	extends Maybe<Object> {
    private None() {}
    @Override public final boolean isNone() { return true; }
    @Override public final <E extends Object> E getOrElse(final E otherwise) { return otherwise; }

    public static final None none = new None();
    public static final <E> Maybe<E> getNone() { return (Maybe<E>)none; }
}

, generics in Java work through a method (to ensure backwards compatibility) called " type erasure" which means that (most) generic type information is lost on compilation. Which means that a List<String> could be equivalent to a List<Integer>, at runtime. So we provide a getter method that simply casts an instance of None to the right Maybe<?> type. This trick is used in the Collections utility class, where it is used for the empty<CollectionType> functions, they store singleton instances for each type, properly specialized for their function and simply return that, type erasure ensures that they have the right type. On the same note, let us add another method that creates Somes. And move them to the Maybe abstract class, seems a little better place for it. This does mean changing the private constructor of the None class to package private. But that isn't such a big deal, it is still private as far as the API is concerned. These helper methods on the Maybe class is also part of the reason for having a base class and not an interface. There are just a few remaining questions for the final api. For instance, should the new some function in Maybe return None on null? It's an interesting question which I can't really give you an answer to. Even if it is because I haven't really made my mind up yet. Null can be a valid value, so it "should" be possible to create a Some with as value null. Perphaps the some function will return None on null, but you can still do new Some(null) and do it that way. But why is this null value keep popping up? And keep being "annoying"? Bugging me about some "code smell" that I can't really put my finger to? What is so unique about null? So different? You can assign it to every reference value. That little fact, I think that might be it for me. It subverts the type system. That would be reason enough for me. While I was writing this post (yeah, other stuff keeps popping up) the very interesting Ola Bini made a post about something called "Bottom Types". I do recommend you to read it, it even mentions the Maybe Monad and null values! I find it uncanny. Well, his post is the better one, that is for sure. It also mentions an origin of the null reference exception, a Sir Tony Hoare calls it the "Million Dollar Mistake". And yes, this person is an authority on the subject. As an interesting bit on the side, C++ has null pointers, but never null references, and references are "managed", but not in a Garbage Collection kind of way, and has had it for quite a while. The null reference really is an error born of Sloth (laziness). While otherwise a (when properly managed) perfectly good and handy trait among programmers it does seem to have given us a quite a few problems down the line since he invented them 44 years ago, and we are still having this problem, even with the Elvis operators coming in Java7, as the Groovy people call them (among other people). And on that note, I think a little recap of what we have done here is in order before I publish this post, and yes, I shall be coming back to this subject in a future post. Especially after I learn more about Type Systems (currently I only "know" them intuitively, nothing concrete, no names or anything like that, just the 4 basic names and the term "type inference"). Sometimes (always?) it is better to be explicit than to use a magic, possibly having double meanings, constant, such as null. Do tell me, you don't also type in the same String literal time and again in the same function? Surely extract all those literals into one final static field? Or even better, switch to enums! So why not for null? Well, null is compile checked, meaning you can't accidently misspell it. And we have seen (thanks to Ola Bini) that null actually subverts the type system! So how can we make this better? Haskell and Scala show us the way, the Maybe Monad. It is a small collection of three classes that are practically as easy to write as a Pair or (simple) Tuple class. Which everyone always seem to write. It allows us to be explicit when a function returns something or does not return something, without being as "heavy" as an exception while still sufficently distinctive and "present" that you have to deal with it, instead of waiting for a nullpointerexception during runtime. Of course, you can be explicit with null, but it is so easy (too easy) to just "ignore" it, even if the JavaDoc explicity states that you need to deal with null. We also retrofitted a map to return Maybe instances, meaning Some if there is a key and None if there isn't, instead of null for either if the value is present and it happens to be null or if it isn't present. And lastly, a code listing of the Maybe class I had written up for this post, you should put it in some utility package:

public abstract class Maybe<T> extends Iterable<T> {
    Maybe() {}
    public abstract <E extends T> T getOrElse(E otherwise);
    public abstract boolean isSome();
    public abstract boolean isNone();
    public abstract int hashCode();
    public abstract boolean equals(Object o);
    public abstract String toString();

    public static <T> Maybe<T> some(T t) {
        if (t == null) {
            return <T>none();
        }
        return new Some<T>(t);
    }
    private static final None _none = new None();
    @SuppressWarnings("unchecked")
    public static <T> Maybe<T> none() {
        return _none;
    }
}

public final class Some<T> extends Maybe<T> {
    private final T some;
    public Some(T t) { some = t; }
    @Override public final <E extends T> T getOrElse(E otherwise) { return some; }
    @Override public final boolean isSome() { return true;  }
    @Override public final boolean isNone() { return false; }
    @Override public final int hashCode() {
        if (some == null) {
            return 0;
        }
        return some.hashCode();
    }
    @Override public final boolean equals(Object o) {
        if (o instanceof Some) {
            if (some == null) {
                return o == null;
            }
            return some.equals(((Some) o).some);
        }
        return false;
    }
    @Override public final String toString() {
        if (some == null) {
            return "Some(null)";
        }
        return new StringBuffer("Some(").append(some.toString).append(')');
    }
    @Override public final Iterator<T> iterator() {
        return Collections.singletonSet(some).iterator();
    }
}

public final class None extends Maybe<Object> {
    None() {}
    @Override public final <E extends T> E getOrElse(E otherwise) { return otherwise; }
    @Override public final boolean isSome() { return false;  }
    @Override public final boolean isNone() { return true; }
    @Override public final int hashCode() {
        return None.class.hashCode();
    }
    @Override public final boolean equals(Object o) {
        return o instanceof None;
    }
    @Override public final String toString() {
        return "None";
    }
    @Override public final Iterator<Object> iterator() {
        return Collections.emptySet().iterator();
    }
}

PS. Fixed the code to implement the Iterable interface, I shouldn't write this at night.