Scala: Generic classes and Variance

Generic classes are classes which take a type as a parameter. This means, one class can be used with different types without actually writing down it multiple times. They are particularly useful for collection classes.

Defining a generic class:

Generic classes take a type as a parameter within square brackets [ ]. One convention is to use the letter A as type parameter identifier, though any parameter name may be used. Let us understand this with the help of an example. As I have already described that generic classes are useful for collection classes, So let’s try to understand the Stack collection.

class MyStack[A](elems: List[A]) {

  def isEmpty: Boolean = elems.isEmpty

  def push(elem: A): List[A] = {
    elem :: elems
  }

  def pop: List[A] = {
    if(!isEmpty) {
      elems.tail
    }
    else {
      throw new NoSuchElementException("pop of an empty stack")
    }
  }

}

This implementation of a MyStack class takes type A as a parameter. This simply means the parameter elems can only store elements of type A. The method push only accepts objects of type A.

Now as we understood how to define the generic classes, let’s understand how to use them.

Usage:

To use a generic class, put the type in the square brackets in place of A.

val list = List(1, 2, 3, 4)
val stack = new MyStack[Int](list)
stack.push(5)
stack.push(6)
println(stack.pop)  // prints 6
println(stack.pop)  // prints 5

Here, the stack can only take Ints. However, if the type argument had subtypes, those could be passed in:

class Animal
class Cat extends Animal
class Dog extends Animal

val list = List[Animal]()
val cat = new Cat
val dog = new Dog
val stack = new MyStack[Animal](list)
stack.push(cat)
stack.push(dog)

Here, class Cat and Dog both extends Animal so we can push instances cat and dog onto the stack of Animal.

Variance:

Variance defines Inheritance relationships of Parameterized Types. Variance is all about Sub-Typing. Variance makes Scala collections more Type-Safe.
Types of Variance:
1. Covariant
2. Invariant
3. Contravariant

class Stack[+A] // A covariant class
class Stack[-A] // A contravariant class
class Stack[A] // An invariant class

Covariant:

If S is a subtype of T, then List[S] is a subtype of List[T].

In Scala, Syntax to represent covariant relationship between two parametrized types is prefixing Type Parameter with “+” symbol. Let’s understand covariance with the help of an example:

class Animal[+T](val animal:T)

class Dog

class Puppy extends Dog

class AnimalCarer(val dog: Animal[Dog])

object ScalaCovariance extends App {

  val puppy = new Puppy

  val dog = new Dog

  val puppyAnimal: Animal[Puppy] = new Animal[Puppy](puppy)

  val dogAnimal: Animal[Dog] = new Animal[Dog](dog)

  val dogCarer = new AnimalCarer(dogAnimal)

  val puppyCarer = new AnimalCarer(puppyAnimal)

}

As we can see above, class Puppy is a subtype of Dog and we are able to define the dogCarer and puppyCarer both but if we remove the “+” sign we get a compile-time error.

Contravariant:

If S is a subtype of T, then List[T] is a subtype of List[S].

In Scala, Syntax to represent contravariant relationship between two parametrized types is prefixing Type Parameter with “-” symbol. Let’s understand contravariance with the help of an example:

abstract class Type[-T]{
  def typeName(): Unit
}

class SuperType extends Type[AnyVal]{
  override def typeName(): Unit = {
    print("\n\n SuperType \n\n")
  }
}

class SubType extends Type[Int]{
  override def typeName(): Unit = {
    print("\n\n SubType \n\n")
  }
}

class TypeCarer{
  def display(t: Type[Int]){
    t.typeName()
  }
}

object ScalaContravariance {

  def main(args: Array[String]) {
    val superType = new SuperType
    val subType = new SubType

    val typeCarer = new TypeCarer

    typeCarer.display(subType)
    typeCarer.display(superType)
  }

}

As we can see above, class SuperType is a subtype of Type[AnyVal] and class SubType is a subtype of Type[Int]. We can see typeCarer object is able to display both SuperType and SubType but if we remove the “-” sign we get a compile-time error.

Invariant:

If S is a subtype of T then List[S] and List[T] don’t have Inheritance Relationship or Sub-Typing. That means both are unrelated.
In Scala, by default Generic Types have Non-Variant relationship. If we define Parameterized Types without using “+” or “–” symbols, then they are known as Invariants. Let’s understand contravariance with the help of an example:

abstract class Animal {
  def name: String
}

case class Cat(name: String) extends Animal

case class Dog(name: String) extends Animal

class Container[A](value: A) {
  private var _value: A = value
  def getValue: A = _value
  def setValue(value: A): Unit = {
    _value = value
  }
}

object Invariance {

  val catContainer: Container[Cat] = new Container[Cat](Cat("tom"))

  // This won't compile
  val animalContainer: Container[Animal] = catContainer

}

As we can see above, class Cat and Dog are subtypes of Animal. So catContainer compiles fine whearas animalContainer throws compile time error saying Container of type Animal cannot hold Container of type Cat.

Check out my Github repo for complete scala tutorial

Conclusion:

To sum up this blog, we concluded the following:

• Generic classes are classes which take a type as a parameter i.e., one class can be used with different types without actually writing down it multiple times.
• Variance defines Inheritance relationships of Parameterized Types.
• Various types of variance are: Invariant, Covariant and Contravariant.
• Invariant: If S is a subtype of T then List[S] and List[T] don’t have Inheritance Relationship or Sub-Typing.
• Covariant: If S is a subtype of T, then List[S] is a subtype of List[T].
• Contravariant: If S is a subtype of T, then List[T] is a subtype of List[S].

References:

1. Scala Documentation
2. Journal Dev