How to avoid Option.get and pattern match on None for Option that is always Some?

Question

I have this bit of (meta) code which deals with a database object I want to update T .

Only things known are the ID of such object, the query to retrieve it, and the update to perform.

def updateObject(...) : Either[(Int,String),(Int,T)] = {

    T.update(
      query,
      update,
    ) match {

    case 0 => Left(404, "No such object!")
    case _ =>
        T.findOne("id == objectId")
        .map((200, _)) match {
          case Some(result) => Right(result)
          case _ => ???
        }

  }

}

T.update performs an update on objects that satisfy query and returns a write result, which is an integer (number of records affected by the update).

Return type is Either[(Int,String),(Int,T)] :

• Left is meant to be a tuple with this format: (error_code, error_message).
• Right's format is this instead: (status_code, updated_object).

If numbers of affected records is 0, the object doesn't exists, hence I return a Left(404,"No such object") .

If the object has been updated, I need to fetch it (as I only have its id), map it to a (Int,T) and then return it in a Right .

Here's the question :

T.findOne returns Option[T] .

I've already performed an update on the object, therefore it exists and the result will always be Some(T) .

I know that case _ => ??? will never be called, but the compiler will warn me of the match not being exhaustive if I don't put that in.

Is there a better way to deal with this (with Option that is always guaranteed to be Some )?

(I'm trying to avoid Option.get method), and case _ => ??? seems like unnecessary and confusing code.

Answer 1

1st why not Option.get, if you are 100% sure there will be a result. 2nd Option.getOrElse will also cover the extreme edge case where the updated object disappeared before you were able to retrieve it.

How about something like this:

    T.findOne("id == objectId").map(Right(200,_._2)).getOrElse(Left(404,"Insane Corner Case : Updated Object not found"))

Answer 2

I've decided to consider the "extreme" case.

Code has been refactored to:

T
.findOne("id == objectId")
.map((200, _))
.toRight(404, "Object has been deleted")

Thanks to mz for the tip.