Skip to content
Related Articles

Related Articles

Improve Article
Scala – Covariance
  • Last Updated : 03 Jul, 2020

Variance is the interconnection of Sub-Typing relationships which are either of complicated types or of their constituent types. Scala provides three types of variance:

  • Covariant
  • Contravariant
  • Invariant

Covariance states that if there are two parameterized types such that S is a subtype of T, then List[S] is a subtype of List[T]. This is an inheritance relationship. So, this basically defines the relationship whether we can replace a type by its base type. Simply putting in words, if we take an example where Car is a subtype of Vehicle, then List[Car] is a subtype of List[Vehicle]. Therefore, we can replace List[Car] by List[Vehicle]. When we declare a type to be covariant, then its safe use at various positions becomes limited. In the case of immutable types, covariance is widely used.
Syntax:

List[+T]

Here, T is a type parameter and the “+” symbol represents Scala covariance.

Let us discuss this concept with the help of examples:
Example 1:




// Scala program to illustrate the concept of covariance
  
// Creating an abstract class 
// for Flower 
abstract class Flower 
{
    def name: String
}
  
// Creating a sub-class Lily 
// of Flower 
case class Lily(name: String) extends Flower
  
// Creating a sub-class Carnation
// of Flower 
case class Carnation(name: String) extends Flower 
object Covariance extends App
{
      
    // Creating a method
    def FlowerNames(flowers: List[Flower]): Unit =
    {   
        flowers.foreach 
        {
            flower => println(flower.name)
        }
    }
      
    // Assigning names
    val lily: List[Lily] = List(Lily("White Lily"), 
                                Lily("Jersey Lily"))
    val carnations: List[Carnation] = List(Carnation("White carnations"),
                                           Carnation("Pink carnations"))
  
    // Print: names of lily 
    FlowerNames(lily)
  
    // Print: names of carnation 
    FlowerNames(carnations)
}

Output:



White Lily
Jersey Lily
White carnations
Pink carnations

Explanation: In the above example, Lily and Carnation are subtypes of Flower. So, it is evident that a List[Lily] is a List[Flower] and a List[Carnation] is also a List[Flower], and we can substitute any of them for a List[Flower]. In the later part of the code, there is a method FlowerNames that prints names of flowers and the acceptable argument is a list of flowers. If the two lists are covariant, only then the method calls will compile and the flower names will get printed respectively. So, as Lily and Carnation are a subtype of Flowers and the last two lines will execute due to covariance.
Note:

  • Abstract class is utilized here to apply covariance as it has List[+T] with it where the type parameter T is covariant.
  • A trait App is used here to speedily change objects into workable programs.

Example 2:




// Scala program to illustrate the concept of covariance
  
// Creating an abstract class 
// for Animal
abstract class Animal 
{
    def name: String
}
  
// Creating a sub-class Mammal
// of Animal 
case class Mammal(name: String) extends Animal
  
// Creating a sub-class Reptile
// of Animal 
case class Reptile(name: String) extends Animal 
  
object CovarianceExample extends App
{
      
    // Creating a method
    def SpecieNames(animals: List[Animal]): Unit =
    {   
        animals.foreach 
        
            animal =>println(animal.name)
        }
    }
      
    // Assigning names
    val mammals: List[Mammal] = List(Mammal("Zebra"), 
                                     Mammal("Horse"))
    val reptiles: List[Reptile] = List(Reptile("Snake"), 
                                       Reptile("Lizard"))
  
    // Print: names of mammals
    SpecieNames(mammals)
  
    // Print : names of reptiles
    SpecieNames(reptiles)
}

Output:

Zebra
Horse
Snake
Lizard



My Personal Notes arrow_drop_up
Recommended Articles
Page :