[monkeyfacebag]

Guava is definitely cool and I recommend it whenever I can. It's worth noting, however, that, as a Java library, it cannot provide the compile-time guarantees mentioned in the post. That is, your Option type could still be null and so you're still forced to perform run-time null checking. If you want the full benefit of Option types on the JVM, you might be better off with Scala.

[theatrus2]

Scala still has the problem that you can return null explicitly (since references on the JVM are nullable), but any Scala code which does this should probably be shot on sight.

[grdvnl]

The Optional<T> in Guava just forces one to explicitly check for null and then get the container object during development. A typical pattern would be:

Given an object a of type Optional<MyObject>, we write:

if (a.isPresent()){ MyObject o = a.get() }

Of course, I could still do a.get() without evaluating isPresent() and end up with an java.lang.IllegalStateException. Here, we are "reminded" to do the null check.

[mercurial]

You can force Maybe in Haskell, and get a bad surprise at runtime as well.

[mercurial]

Not to mention that it does not make Java magically sprout pattern-matching abilities, which makes dealing with Maybes much more pleasant and natural.

[fyi80]

Yes, you'd need a linter to stop you from using explicit null in your code. but than be layered on top of javac with something FindBugs and its friend @Nullable. It's not "Standard" Java, but it is compiler-time enforcement.