Scala: Type Bounds

Table of contents

Reading Time: 3 minutes

As we have already discussed in my last blog about the Type Parameterization concepts like Generics, Generic classes, and Variance. So to follow up, in this blog we’ll be discussing type bounds.

Type Bounds:

How can we create type parameter restrictions? To create them we make use of Scala type bounds. In Scala, Type Bounds are restrictions on Type Parameters or Type Variable. By using Type Bounds, we can define the limits of a Type Variable. Scala Type Bounds give us the benefit of Type-Safe Application Development.
Scala supports the following Type Bounds for Type Variables:

Scala Upper Bounds
Scala Lower Bounds

We’ll be discussing these types in detail with examples one by one.

Upper Type Bounds:

In Scala, we define upper bound on the Type parameter as shown below:

Here T is a Type Parameter and S is a type. By declaring Upper Bound like [T <: S] means this Type Parameter T must be either same as S or Sub-Type of S. Let us understand this with the help of an example.

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[T <: Pet](t: T) {
def pet: T = t
}

object UpperTypeBounds extends App {
val dogContainer = new PetContainer[Dog](new Dog)
val catContainer = new PetContainer[Cat](new Cat)

// this would not compile
val lionContainer = new PetContainer[Lion](new Lion)

}

Here, PetContainer class takes a type parameter T which has an upper bound Pet i.e., T can be either Pet or a subtype of Pet. Therefore, dogContainer and catContainer are valid values whereas lionContainer is not as Lion is not a subtype of Pet.

Lower Type Bounds:

In Scala, we define upper bound on the Type parameter as shown below:

Here T is a Type Parameter and S is a type. By declaring Lower Bound like [T >: S] means this Type Parameter T must be either same as S or Super-Type of S. Let us understand this with the help of an example.

trait Thing

class Vehicle extends Thing

class Car extends Vehicle

class Jeep extends Car

class Coupe extends Car

class Motorcycle extends Vehicle

class Bicycle extends Vehicle

class Tricycle extends Bicycle

// We need to restrict parking to all subtypes of vehicle, above Tricycle

class Parking[T >: Bicycle <: Vehicle](val plaza: T)

object LowerTypeBounds extends App {

  // this won't compile
  val parking1 = new Parking[AnyRef](new AnyRef)

  // this will compile
  val parking2 = new Parking[Bicycle](new Bicycle)

  // this won't compile
  val parking3 = new Parking[Thing](new Thing{})

}

Here, we try to restrict the parking for subtypes of Vehicle above Tricycle. So we have declared an upper bound Vehicle and a lower bound Bicycle. Therefore, parking1 and parking3 values simply won’t compile as AnyRef is a supertype of reference types and we have restricted the upper bound to Vehicle and Thing is also a supertype of Vehicle. parking2 works absolutely fine as it lies in the range of Bicycle and Vehicle.

Conclusion:

So to summarize, Type Bounds are nothing but used to enforce the restrictions on the Type parametrizations. Scala provides two types of Type Bounds namely Lower Type Bounds which are basically used to restrict the subtypes and Upper Type Bounds which are used to restrict the supertypes.

For Full Scala tutorial refer to my Github repository Scala Tutorial.