In Scala, type parameters and abstract type members may be constrained by a type bound. Such type bounds limit the concrete values of the type variables and possibly reveal more information about the members of such types. An upper type bound T <: A declares that type variable T refers to a subtype of type A. Here is an example that demonstrates upper type bound for a type parameter of class PetContainer:
abstract class Animal { def name: String } abstract class Pet extends Animal {} class Cat extends Pet { override def name: String = "Cat" } class Dog extends Pet { override def name: String = "Dog" } class Lion extends Animal { override def name: String = "Lion" } class PetContainer[P <: Pet](p: P) { def pet: P = p } val dogContainer = new PetContainer[Dog](new Dog) val catContainer = new PetContainer[Cat](new Cat) abstract class Animal: def name: String abstract class Pet extends Animal class Cat extends Pet: override def name: String = "Cat" class Dog extends Pet: override def name: String = "Dog" class Lion extends Animal: override def name: String = "Lion" class PetContainer[P <: Pet](p: P): def pet: P = p val dogContainer = PetContainer[Dog](Dog()) val catContainer = PetContainer[Cat](Cat()) // this would not compile val lionContainer = new PetContainer[Lion](new Lion) // this would not compile val lionContainer = PetContainer[Lion](Lion()) The class PetContainer takes a type parameter P which must be a subtype of Pet. Dog and Cat are subtypes of Pet so we can create a new PetContainer[Dog] and PetContainer[Cat]. However, if we tried to create a PetContainer[Lion], we would get the following Error:
type arguments [Lion] do not conform to class PetContainer's type parameter bounds [P <: Pet]
This is because Lion is not a subtype of Pet.