Errors with Akka-Typed Java

Question

The Akka documentation makes a distinction between validation error and failure. But, while there is a complete chapter on failure, I did not see much on validation error.

A validation error means that the data of a command sent to an actor is not valid, this should rather be modelled as a part of the actor protocol than make the actor throw exceptions.

-- https://doc.akka.io/docs/akka/current/typed/fault-tolerance.html

I searched a bit but still was not able to find much information on that subject. At this time, I see two options;

Option 1, type hierarchy:

We can use a type hierarchy to have a typed structure an link between a command, his successful answer and errors:

class MyCommand { 
   ActorRef<MyCommandAnswer> replyTo;
   // .. 
}
interface MyCommandAnswer { }
class MyCommandSuccess implements MyCommandAnswer { /* .. */ }
class MyCommandError implements MyCommandAnswer { /* .. */ }

The nice thing is that there is a strong relationship between the command and the two possibles case of answers.

However, this is verbose and the type of answer is not obvious (we have to read the type hierarchy to discover possible types). Moreover, the answer must be handled with instanceof or a visitor like pattern (that will not reduce the verbosity)

Option 2, an Either like

Scala has an Either type that can be Left or Right. Left is usually holding an error while the Right side contains a success. There is also Try that use the same pattern.

Represents a value of one of two possible types (a disjoint union). An instance of Either is an instance of either scala.util.Left or scala.util.Right.

-- https://www.scala-lang.org/api/2.13.3/scala/util/Either.html

We can create a similar type that will be replied by our actors.

abstract class Either<L, R> {
  public static <L> Either<L, ?> left(L error) {
    return new Left(error);
  }
  public static <R> Either<?, R> right(R value) {
    return new Right(value);
  }

  public abstract boolean isLeft();
  public abstract boolean isRight();
  public abstract <O> Either<L, O> map(Function<R, O> mapping);
  public abstract <O> O orElse(Supplier<O> other);
  // ...
}


class MyCommand {
  ActorRef<Either<MyCommandError, MyCommandSuccess>> replyTo;
  // ..
}

The good thing is that we always know the possible answer and the Either class can be reused across all actors. Which makes the usage easier in the project. We can have many methods of that type to deal with the two cases and do not have to duplicate the code for all commands.

This a bit of functionally inspired code that may not be natural to everyone.

---

My preference is obviously for the Either type. But I would like to have the knowledge of the community on that topic.

So, my question is, how did you manage errors with Akka-typed and Java ?

Thanks

Answer 1

StatusReply is intended as a good encoding of success/error responses for actor protocols, see docs: https://doc.akka.io/docs/akka/current/typed/interaction-patterns.html#generic-response-wrapper