Can a function return one of multiple types which do not share a common ancestor?

Question

Of course I realize all types do have a common ancestor, but what I mean is this:

In dynamically-typed languages, it is a common practice to have 'mixed' return types. A common case is a function which attempts to retrieve data from a database, then returns either an object (initialized with the found data) or FALSE (in the event no data was found).

A little pseudocode to demonstrate just such an anti-pattern:

function getObjectFromDatabase(object_id) {
  if(result = db_fetch_object("SELECT * FROM objects WHERE id = %d", object_id) {
    return result
  } else {
    return FALSE
  }
}

If data is found for my object id, I get a DB record back as an object. If not, I get a boolean value. Then, of course, it is on me, the client, to handle multiple possible return types.

Is the only way to accomplish this in Scala to find a common ancestor for all possible return types and declare that as the return type in the signature?

// Like so:
def getObjectFromDatabase(objectId: Int): Any = {
   val result = dbFetchObject("SELECT * FROM objects WHERE id = %d", object_id) 
   if(result) {
     return result
   } else {
     return false
  }
}

Or is it possible to annotate multiple possible return types?

(Note that I do not hope it is possible to do this, as I would prefer it to be enforced that function return types are as unambiguous as possible. It would come as a relief to me to learn that the language forbids ambiguous return types, which is more the reason I am asking.)

Answer 1

Yes, use Either:

def getObjectFromDatabase(objectId: Int): Either[Boolean, DbResult] = {
   val result = dbFetchObject("SELECT * FROM objects WHERE id = %d", object_id) 
   if (result) Right(result) else Left(false)

}

getObjectFromDatabase(id) match {
  case Right(result) => // do something with result
  case Left(bool) => // do something with bool
}

Or, if the no results case doesn't need a specific value, use Option:

def getObjectFromDatabase(objectId: Int): Option[DbResult] = {
   val result = dbFetchObject("SELECT * FROM objects WHERE id = %d", object_id) 
   if (result) Some(result) else None
}

getObjectFromDatabase(id) match {
  case Some(result) => // do something with result
  case None => // do something about no results
}

See Tony Morris' Option Cheat Sheet for a list of the most common methods you can call on Option and how they translate to pattern matching.

Two other alternatives are Validation from scalaz and Try, new in Scala 2.10.

For Validation there are some really good answers on StackOverflow, for example: Method parameters validation in Scala, with for comprehension and monads.

For Try see this blog post: The Neophyte's Guide to Scala Part 6: Error Handling With Try. The same author has good posts on Option and Either.