Abstract versus parameterized types

Both are forms of providing polymorphic abstractions in Scala. Mostly, it's a design choice whether you prefer one over the other. Talking about design choices, let's have a closer look. For that we'll take an example where we have two class hierarchies as follows:

abstract class Food 
class Grass extends Food 
class Meat extends Food 
 
abstract class Animal { 
   type SuitableFood <: Food 
   
   def eatMeal(meal: SuitableFood) 
} 

From the knowledge about abstract types and upper bounds we can say Animal is an abstract class, which has an abstract type member named SuitableFood, which expects only the Food type. If we declare two subtypes of Animal class namely Cow and Lion it could look like a cow can eat Grass as well as Meat because both are subclasses of Food. But this isn't the desired behavior. To resolve the issue, we can declare Cow like this:

class Cow extends Animal { 
  type SuitableFood <: Grass 
 
  override def eatMeal(meal: SuitableFood...