Is it wrong to give the unit back? - scala

Question

I have the following function:
private def constraintToJson(req: => Request[IO])
: EitherT[IO, Throwable, Unit]
= {
val err: EitherT[IO, Throwable, Unit] = EitherT.fromEither[IO](Left(new Exception("Not JSON format request.")))
req.contentType match {
case Some(s) =>
if (s != `Content-Type`(MediaType.`application/json`))
err
else
EitherT.fromEither[IO](Right(()))
case None =>
err
}
}
The question is, it is wrong to return a Unit if it is right or there is another choice?

Answer 1

I think that returning Unit (wrapped into Either/EitherT) might be OK if this is a kind of the final step of your computation and it actually does not produce any output. In other cases (most probably including yours) you should return some value for the successful case so that you can chain it further. So the main question is: how constraintToJson is supposed to be used? The obvious suspect for your case is returning Request or its body if the Content-Type matches JSON because this is most probably the data that will be used by the next step.

Answer 2

Simplified Question
Let me abstract your problem first by removing IO.
The question is whether a method with a signature like the following is useful:
def validate[A](a: Request[A]): Either[Error,()] =
if(isOk(a.someProperty)) Left(()) else Right("invalid")
Noting that Either[A,()] =:= Option[A], this method checks for the presence of any Error in the value of the request, and returns this Error, if detected.
What could be done with such a method?
Check and exit
We could write a program that checks a Request:
val someRequest: Request[X] = getRequestFrom("somewhere")
validate(someRequest).toLeft.foreach{error =>
println("invalid request: " + error
System.exit(-1)
}
System.exit(0)
In this case validate has a useful signature.
Check and go on
We could also validate a request, and then go on to execute it:
val someRequest: Request[X] = getRequestFrom("somewhere")
validate(someRequest) match {
case Left(error) =>
println("invalid request: " + error)
System.exit(-1)
case Right(_) =>
println("executing request: " + someRequest.execute)
System.exit(0)
}
While this code works perfectly well, it throws away an argument (_) in the second match clause. This is an indicator of some bad design. The code within the case Right(_) takes the value someRequest from outside, and treats it as a valid request because of the way you wrote your code.
If we would call someReuqest.execute within the Left case, we would probably end up with a runtime exception when executing an invalid Request.
Depending on our desired level of rigor, this can be a code smell.
We can improve the code in the following way.
Using a Non-Unit return type
We can circumvent returning Unit by simply returning the checked argument.
This appears to be a bit redundant, and we shall later see how to turn the returned value into something useful.
But let's first look at this option.
def validateTyped[A](a: Request[A]): Either[Error,Request[A]] =
if(isOk(a.someProperty)) Left(a) else Right("invalid")
Then we can write the Check and go on code as
val someRequest: Request[X] = getRequestFrom("somewhere")
validate(someRequestTyped) match {
case Left(error) =>
println("invalid request: " + error)
System.exit(-1)
case Right(validatedRequest) =>
//we now execute the validated request
println("executing request: " + validatedRequest.execute)
System.exit(0)
}
Now this improves the code a bit.
We don't throw away a returned value anymore in the second match clause.
We can execute the validatedRequest, because we've read in the documentation of validateRequest that a returned Right value is well formed, and it may be executed without error.
Looks good, right?
But we can do better.
Prevent execution of malformed requests
We can still improve it further by totally preventing executing a malformed Request by changing our Request type.
case class Request[A](query: String){
def validate: Either[Error,ValidRequest[A]] = ???
}
case class ValidRequest[A](query: String){
def execute: A
}
With this code, it is not possible to call Request.execute anymore, as a validation now becomes mandatory.
Otherwise the code will not compile.
We also note that the Right value returned by Request.validate is now needed.
It has become the only source of obtaining a ValidRequest.
Now it is impossible to call execute a Request that isn't validated, yet:
val someRequest: Request[X] = getRequestFrom("somewhere")
someRequest.validate match {
case Left(error) =>
println("invalid request: " + error)
System.exit(-1)
case Right(validatedRequest) =>
println("executing request: " + validatedRequest.execute)
System.exit(0)
}
Conclusion
In this way we have turned a strange looking method that returned Unit into a method that returns a meaningful and needed value.
In addition it has become impossible to execute a Request that has not been validated successfully.