Name: dataenum
Owner: Spotify
Description: Algebraic data types in Java.
Created: 2017-12-14 14:55:41.0
Updated: 2018-05-15 22:04:48.0
Pushed: 2018-05-15 11:53:48.0
Size: 147
Language: Java
GitHub Committers
| User | Most Recent Commit | # Commits |
|---|
Other Committers
| User | Most Recent Commit | # Commits |
|---|
DataEnum allows you to work with algebraic data types in Java.
You can think of it as an enum where every individual value can have different data associated with it.
The idea of algebraic data types is not new and already exists in many other programming languages, for example:
It is possible to represent such algebraic data types using subclasses: the parent class is the “enumeration” type, and each child class represents a case of the enumeration with it's associated parameters. This will however either require you to spread out your business logic in all the subclasses, or to cast the child class manually to access the parameters and be very careful to only cast if you know for sure that the class is of the right type.
The goal of DataEnum is to help you generate all these classes and give you a fluent API for easily accessing their data in a type-safe manner.
The primary use-case we had when designing DataEnum was to execute different business logic depending on an incoming message. And as mentioned above, we wanted to keep all that business logic in one place, and not spread it out in different classes. With plain Java, you?d have to write something like this:
message instanceof Login) {
Login login = (Login) message;
// login logic here
se if (message instanceof Logout) {
Logout logout = (Logout) message;
// logout logic here
There are a number of things here that developers tend to not like: repeated if-else statements, manual instanceof
checks and safe-but-noisy typecasting. On top of that it doesn't look very idiomatic and there's a high risk that
mistakes get introduced over time. If you use DataEnum, you can instead write the same expression like this:
age.match(
ogin -> { /* login logic; the 'login' parameter is 'message' but cast to the type Login. */ },
ogout -> { /* logout logic; the 'logout' parameter is 'message' but cast to the type Logout. */ }
In this example only one of the two lambdas will be executed depending on the message type, just like with the
if-statements. match is just a method that takes functions as arguments, but if you write expressions with linebreaks
like in the example above it looks quite similar to a switch-statement, a match-expression in Scala, or a
when-expression in Kotlin. DataEnum makes use of this similarity to make match-statements look and feel like a
language construct.
There are many compelling use-cases for using an algebraic data type to represent values. To name a few:
Create a vocabulary of possible actions. List all the actions that can be performed in a certain part of your application, for example on a login/logout page. Each action can have different data associated with it, for example the login action would have a username and password, while a logout action doesn't have any data.
Representing states of a state machine. This allows you to only keep the data that actually is available in each state, making it impossible to even reference data that isn't available in a particular state.
Rich, type-safe error handling Instead of having just an error code as a result of a network request, you can
have different types for different errors, each with relevant information attached: ConnectivityLost,
NoRouteToHost(String host), TooManyRetries(int retryCount).
Metadata in RxJava streams. It is often useful to wrap data in RxJava in order to provide metadata about what's
happening. One common example is to represent different kinds of success and failure: InProgress(T placeholder),
Success(T data), Error(String reason).
DataEnum is in Beta status, meaning it is used in production in Spotify Android applications, but we may keep making changes relatively quickly.
It is currently built for Java 7 (because Android doesn't support Java 8 well yet), hence the
duplication of some concepts defined in java.util.function (Consumer, Function, Supplier).
The latest version of DataEnum is available through Maven Central (LATEST_RELEASE below is ):
ementation 'com.spotify.dataenum:dataenum:LATEST_RELEASE'
tationProcessor 'com.spotify.dataenum:dataenum-processor:LATEST_RELEASE'
endencies>
ependency>
<groupId>com.spotify.dataenum</groupId>
<artifactId>dataenum</artifactId>
<version>LATEST_RELEASE</version>
dependency>
ependency>
<groupId>com.spotify.dataenum</groupId>
<artifactId>dataenum-processor</artifactId>
<version>LATEST_RELEASE</version>
<scope>provided</scope>
dependency>
pendencies>
It may be an option to use the annotationProcessorPaths configuration option of the maven-compiler-plugin rather than an optional dependency.
First, you define all the cases and their parameters in an interface like this:
aEnum
rface MyMessages_dataenum {
dataenum_case Login(String userName, String password);
dataenum_case Logout();
dataenum_case ResetPassword(String userName);
Then, you apply the dataenum-processor annotation processor to that code, and your DataEnum case
classes will be generated for you.
Some things to note:
We use a Java interface for the specification. The rationale is that it allows the IDE to help you find and import types correctly. We deliberately made it look weird, so nobody would think it?s a normal class. This is abusing Java a bit, but we?re OK with that.
The interface will never be used for anything other than code generation, so you should normally
make the interface package-private. The one exception is when one _dataenum spec needs to
reference another as described below.
The interface name has to end with _dataenum. This is to make the interface stick out and make
it easier to filter out from artifacts and exclude from static analysis.
The methods in the interface have to be declared as returning a dataenum_case. Each method
corresponds to one of the possible cases of the enum, and the parameters of the method become the
member fields of that case. Note that the method names from the interface will be used as class names
for the cases, so you'll want to name them using CamelCase as in the example above. The methods
in the _dataenum interface will never be implemented, and there is no way to create a dataenum_case
instance. The type is only used as a marker.
The prefix of the @DataEnum annotated interface will be used as the name of a generated super-class
(MyMessages in the example above). This class will have factory methods for all the cases.
For each method in the interface, an inner class will be generated (in this example MyMessages.Login,
MyMessages.Logout and MyMessages.ResetPassword). These classes will extend the outer class MyMessages.
Some usage examples, based on the @DataEnum specification above:
nstantiate by passing in the required parameters.
ou?ll get something that is of the super type - this is to help Java?s
ot-always-great type inference do the right thing in many common cases.
ssages message = MyMessages.login("petter", "s3cr3t");
f you actually needed the subtype you can easily cast it using the as-methods.
ut logout = MyMessages.logout().asLogout();
or every as-method there is also an is-method to check the type of the message.
rtThat(message.isLogin(), is(true));
pply different business logic to different message types. Note how getters are generated (but not
etters, DataEnum case types should be considered immutable).
age.match(
login -> Logger.debug("got a login request from user: {}", login.userName()),
logout -> Logger.debug("user logged out"),
resetPassword -> Logger.debug("password reset requested for user: {}", resetPassword.userName())
o far we've been looking at 'match', but there is also the very useful 'map' which is used to
ransform values. When using 'map' you define how the message should be transformed in each case.
passwordLength = message.map(
login -> login.password().length(),
logout -> 0,
resetPassword -> -1);
here are some utility methods provided that allow you to deal with unimplemented or illegal cases:
passwordLength = message.map(
login -> login.password().length(),
logout -> Cases.illegal("logout message does not contain a password"), // throws IllegalStateException
resetPassword -> Cases.todo()); // throws UnsupportedOperationException
ometimes, only a minority of cases are handled differently, in which case a 'map' or 'match'
an lead to duplication:
passwordLength = message.map(
login -> handleLogin(login),
logout -> Cases.illegal("only login is allowed"),
resetPassword -> Cases.illegal("only login is allowed")
// This could really get bad if there are many cases here
or those scenarios you can just use regular language control structures (like if-else):
message.isLogin()) {
turn handleLogin(message.asLogin()); // Technically just a cast but easier to read than manual casting.
se {
row new IllegalStateException("only login is allowed");
Case types are immutable. All generated classes are value types and cannot be modified after being created. Of course this assumes that all the parameters of your cases are immutable too, since an object only is immutable if all its fields also are immutable.
Everything is non-null by default. Passing in a null will cause an exception to be thrown unless you explicitly
annotate the parameters as @Nullable. Any annotation with the name 'Nullable' can be used.
toString, hashCode, and equals are generated for all case classes.
isFoo/asFoo methods are provided, as a more high level alternative to manually doing instanceof and casting.
Generic type support. The DataEnum interfaces can be type parameterized, which makes it possible to create reusable data types.
Recursive data type support. The generated DataEnum types may refer to itself recursively, even with type parameters.
When doing so you must use the _dataenum-suffixed name to avoid any chicken-and-egg problems with the generated
classes.
The recursive data type support allows you to do things like this:
aEnum
rface Tree_dataenum<T> {
enum_case Branch(Tree_dataenum<T> left, Tree_dataenum<T> right);
enum_case Leaf(T value);
Sometimes, you want to reference a dataenum from another one. You can do that using this slightly clunky syntax:
rface First_dataenum {
enum_case SomeCase();
rface Second_dataenum {
enum_case NeedsFirst(First_dataenum first);
The generated NeedsFirst class will have a member field that is of the type First. Again, because
the First class doesn't exist until the annotation processor has run, so the Second_dataenum spec
must reference the First_dataenum spec. If First_dataenum is in a different package than
Second_dataenum, it must of course be public.
If you have sensitive information in a field and don't want the generated toString method to
print that information, you can use the @Redacted annotation:
enum_case UserInfo(String name, @Redacted String password);
We provide an annotation in the runtime dependencies, but any annotation named Redacted will work.
DataEnum currently has a single configurable setting determining the visibility of constructors in
generated code. Generally speaking, private is best as it ensures there is a single way of creating
case instances (the generated static factory methods like MyMessages.login(String, String) above).
However, for Android development, you want to keep the method count down to a minimum, and private
constructors lead to synthetic constructors being generated, increasing the method count. Since that
is an important use case for us, we've chosen the package-private as the default. This is configurable
through adding a
@ConstructorAccess
annotation to a package-info.java file. See the javadocs for more information.
While the generated classes are immutable, they do not enforce that parameters are immutable. It is up to users of DataEnum to eg. use ImmutableList for lists instead of List.
The names of the arguments to the lambdas when using match/map only indicate the type of the object by convention,
so some discipline is required to make sure you manually update lambda argument names if a case is renamed.
Renaming cases of a dataenum can be painful since the generated class doesn't have a connection to the interface.
Reordering cases can be dangerous if you only use lambdas with type-inference. If you swap the order of two cases
with the same parameter names then usages of map/match will still compile even though they are now incorrect.
This can be mitigated using method references instead of lambdas, lambdas with explicit type parameters, and good test
coverage of code using DataEnum.
The _dataenum-suffixed interface is only used as an input to code generation, and it breaks certain conventions
around naming. You might need to suppress some static analysis when you use DataEnum, and you probably want to strip
the _dataenum classes from artifacts.
An alternative implementation of algebraic data types for Java is ADT4J. We feel DataEnum has the advantage of being less verbose than ADT4J, although ADT4J is more flexible in terms of customising your generated types.
The name ?DataEnum? comes from the fact that it?s used similarly to an enum, but you can easily and type-safely have different data attached to each enum value.
This project adheres to the Open Code of Conduct. By participating, you are expected to honor this code.