[Haskell-cafe] On the parallel between java annotations and monads
Hello, 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. []'s Rafael ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] On the parallel between java annotations and monads
Could you clarify on what is the precise relationship between the annotations and monads? Or at least an example, like, "The @Foo annotation corresponds to the Cont monad in the following way:..." I personally don't see any connection at all, although I'm rather familiar with both. 2009/7/3 Rafael Almeida : > Hello, > > 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. > > []'s > Rafael > ___ > Haskell-Cafe mailing list > Haskell-Cafe@haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > -- Eugene Kirpichov Web IR developer, market.yandex.ru ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] On the parallel between java annotations and monads
I see some parallels between Inversion of Control/Dependency Injection frameworks and monads. I would say annotations are tools that are sometimes used for those frameworks, but they are also used for other unrelated things (warning suppression, overriding functions ...) so it may be more clear to focus on IoC and DI instead of annotations. -Keith 2009/7/3 Rafael Almeida : > Hello, > > 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. > > []'s > Rafael > ___ > Haskell-Cafe mailing list > Haskell-Cafe@haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > -- keithsheppard.name ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe