Comments on: Algebraic datatypes in Java

By: Victor Nazarov

Victor Nazarov — Fri, 29 Jan 2016 10:57:05 +0000

Here is my library [adt4j](https://github.com/sviperll/adt4j) that allows you to use visitor pattern like presented in the above examples, but spend yourself from writing an excess of boilerplate code required by Java language. Adt4j generates “sealed” subclasses with many convinience methods.

By: Cláudia

Cláudia — Wed, 10 Aug 2011 18:05:58 +0000

Maybe you should take a look at the Tom language:
– http://tom.loria.fr
Tom is embedded in Java and offers constructs for FP in OO. In Tom, we have two ways to define your ADT:
1 – Define the Java classes you want to use and handwrite a mapping from an ADT to it by using constructs provided by Tom;
2 – Write a BNF grammar of your ADT and use the Gom tool to generate both java classes and mapping.
After that, we can apply pattern matching over the algebraic terms inside java methods. For instance, your example in Tom+Gom would be:

import visitor.visitor.types.*;
public class Visitor {
%gom {
module Visitor
imports int
abstract syntax
Tree = EmptyTree()
| Leaf(value:int)
| Node(left: Tree, right: Tree)
}

public static void main(String[] args) {
Visitor v = new Visitor();
Tree tree = `Node(Node(Leaf(0),EmptyTree()),EmptyTree());
int result = v.height(tree);
System.out.println(result);
}

public int height(Tree t) {
%match(t) {
EmptyTree() -> { return 0; }
Leaf(x) -> { return 1; }
Node(l,r) -> { return 1 + Math.max(height(`l), height(`r)); }
}
return -1;
}
}

Well, I don’t know if it’s interesting for you (yes, I saw your post is a little old now). Anyway, here are my five cents. =)

By: matteo

matteo — Sat, 14 May 2011 11:42:09 +0000

Andrea: fixed, thanks! :-)

By: Andrea Mariottini

Andrea Mariottini — Wed, 11 May 2011 09:04:15 +0000

So we wrote a builder implemented as a visitor!

Off topic: I noted all posts of your blog have minutes = hour!

By: matteo

matteo — Tue, 10 May 2011 16:51:13 +0000

@Andrea: if I understand correctly, what you have looks more like a builder than a visitor. With “builder” the intent is to map an abstract tree to something else, in a way that lets you change how you define the “something else”.

By: Andrea Mariottini

Andrea Mariottini — Fri, 06 May 2011 21:04:44 +0000

Hi Matteo, with my team I came to the same solution in a situation where we have to turn “in memory filters” into database queries (in our case Hibernate queries). In this case the visitor is a generic and the getResult method returns a Query object but it could be implemented to return an sql string. This leave us the possibility to change Hibernate with Jdbc or whatever else, if needed.
The choise seemed very natural and produced elegant code, but thinking to OCP the situation is reverted with respect to your example: it is more likely we need to add new filters rather than add new database implementations, so we’ll have to modify the visitor code violating OCP.
However I prefer to not depend on the database layer so I choosed to close the code with respect to the database layer and let it open with respect to the need of new filters.
I would like to have your opinion on this.

By: Erik

Erik — Fri, 11 Mar 2011 13:39:42 +0000

Hi Matteo, if you ever get round to working with Scala, I’d be interested to know how you fare. If you’re an XP aficionado as well as a sufferer from Haskell envy, you may well be chuffed to bits with it. Anyway, get well soon, and sorry about hijacking your comments. ;)

By: matteo

matteo — Fri, 11 Mar 2011 12:15:13 +0000

Erik,

thank you for your sensible response. It’s true that I looked at Scala very superficially. It might well be that you’re right and I’m wrong. I will pospone judgment to when/if I get to work with Scala.

I will answer about Java being simple: why, yes, it looks to me it’s a comparatively simple language. It’s much simpler than C++, and much safer than C. There are dark corners that most programmers don’t know, but the subset of what is well known is mostly the same for most people. I think it’s simple enough for the purposes of application programmers, which are the primary audience for this language.

By: Erik

Erik — Fri, 11 Mar 2011 11:03:20 +0000

Case classes aren’t a ‘different kind’ of class; they are simply classes that will give you some stuff for free, like an extractor (for matching), a builder (so you won’t have to call new), #equals, etc. These are all implementable in standard Scala though, so there’s nothing ‘different’ about case classes. They’re ‘just’ syntactic sugar in that sense, but you can see for yourself what an enormous difference it makes.

Scala is precisely about having a small language (e.g. no special constructs for enums, static methods, etc.) and applying OO/FP principles uniformly (e.g. the collections library). I don’t mean this in a pedantic way, but from your comment I suspect you might have looked at Scala somewhat superficially. (Sorry if this makes me sound like a douche.)

I could imagine how it might make sense to agree on a subset of Scala, but that may depend a lot on your problem domain. Some problems are more amenable to a FP approach, some are more suitable for OO.

It also puzzles me that someone would call Java ‘simple’. I suppose it depends on your definition of simple, and it may be down to taste as well, but Java certainly isn’t simple in any way that is meaningful to me.

Anyway, thanks for sharing your thoughts!

By: matteo

matteo — Fri, 11 Mar 2011 08:24:05 +0000

@Erik: yes, Scala implements algebraic datatypes directly, at the cost of defining “case classes” as a different kind of class, together with particular ways to construct terms and functions. But as the Java example shows, you could implement them with ordinary classes.

This is what I dislike about Scala: they want to have every language feature, and they add new, different concepts to the language to support them. What ever happened to the good old principle of defining a language around few concepts applied uniformly?

The attitude that simplicity is not important is what makes working with Java Enterprise (and most Java frameworks) a pain. This is what makes C++ and Perl impractical engineering tools (because they require inordinate amounts of training to learn to use well.)

I’m afraid Scala joins C++ and Perl in the class of languages where every developer only knows and uses a subset of the language, and no two developers use the same subset. This would make it a poor engineering tool.