Matching covariant list - scala

Question

I have a base class (let us name it Base) and multiple extended classes and method for validation validate which accepts Any.
I would like to check if the parameter is a subclass of Base so I can call validate method from it and also if it is List of instances of subclass of Base to do the same.
I tried the code below, but this does not compile. Is there a simple, elegant way of doing this?
class Base {
def validate(): Unit = {}
}
class Extended1 extends Base {
override def validate(): Unit = {
// some checks
}
}
def validate(param: Any): Unit = {
param match {
case b: Base => b.validate()
// this is not working
case l: List[+Base] => l.foreach(_.validate())
case _ => // do nothing
}
}
UPDATE:
I can use override of methods. I have some more checks which I removed from question, and that was mistake, sorry.
So:
def validate(param: Any): Unit = {
if (Option(param).isEmpty) throwMissingReqFieldException(param)
param match {
case b: Base => b.validate()
case _ =>
}
}
def validate(param: List[Any]): Unit = {
if (Option(param).isEmpty || fieldValue.isEmpty) throwMissingReqFieldException(param)
// here I would like to recursively call validate if possible, maybe this is the solution
param.foreach(x => validate(x))
}

Answer 1

Try approach with a type class
trait Validate[T] {
def validate(t: T): Unit
}
object Validate {
implicit def defaultValidate[T]: Validate[T] = _ => ()
implicit val baseValidate: Validate[Base] = _.validate()
implicit def baseListValidate[B <: Base]: Validate[List[B]] = _.foreach(_.validate())
}
def validate[T](param: T)(implicit v: Validate[T]): Unit = v.validate(param)

Answer 2

If you absolutely need an Any as a parameter, do this:
def validate(param: Any): Unit = {
param match {
case b: Base => b.validate()
case l: List[Base] => if (list.forall(_.isInstanceOf[Base])) l.foreach(_.validate())
case _ => // do nothing
}
}
Here, the [Base] part is actually useless, but it tells the compiler to treat your list as a List[Base]. The actual check is in the if statement, where you make sure all of the objects are Base objects.
You could also do l.foreach(b => if (b.isInstanceOf[Base]) validate(b)) if you don't care that the list doesn't contain only Bases and also could also contain Strings or whatever
A better way to do it would be overloading, though:
def validate(b: Base): Unit = b.validate()
def validate(l: List[Base]): Unit = l.foreach(validate)