[Haskell-cafe] On the parallel between java annotations and monads

Rafael Almeida almeidaraf at gmail.com
Fri Jul 3 09:55:12 EDT 2009


After an extensive search (5 minutes googling) I could not find any comparison
between Java annotations (or Python annotations for that matter) and Monads. I
think they are similar in various aspects and I want to discuss them here.

I'm sure several of you have experience with Java programming and its annotation
system. At first they seem like an extension to the typing system, by using
annotations a single variable or method may have more than one type: the real
type and all the annotations types. The way you declare them is not important
for this discussion, but assume that you've created the annotations
GreaterThanFive and LessThanTwenty, you could annotate a method like
this (let's
forget about all the class verbosity for a while):

        @GreaterThanFive @LessThanTwenty int doYourThing();

You could than use reflection to read those annotations and you could check if
the returned integer is in the correct range. You could even make the compiler
generate code that will do that checking automatically for you.

Even though that was my first impression of them, that's not really
how they are
used in practice (at least the practice that I have experimented). People use
them to implement Monad-like features to the language. Actually, you can forget
monad and think of computation containers.

On an EJB environment there's something called a container and it will do all
sorts of computations when you call an annotated method or when you
create a new
annotated class. For instance, if, inside of an entity bean, you annotate a
variable like this:

        @Column(name = "NAME") private String name;

then, when you create a method like so:

        public String getName()
                return name;

that name is actually something retrieved from the database, even though, it
looks just like something in memory. As far as I know the interaction with
monads for handling databases is not very different. There are other annotations
which allows the container to "inject" some object on a variable, such as:

        @PersistenceContext private EntityManager entityManager;

now you won't even create an EntityManager instance, but will use the object
living inside the container. I compare that to getting a value from an State
Monad. Like there, you'll do some computations using entityManager, but it will
ultimately be returned to the container.

While each computational container in Haskell is very rigid and well
defined, in
java there's nothing rigorous about the annotation. However, quite often the
annotations in Java are used in a manner similar to the implementation of a
Monad in Java.


More information about the Haskell-Cafe mailing list