# SKB – Scala Covariance

## Introduction

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala Covariance.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

## What are we learning today?

Today we are going to learn about Scala Covariance !

Let’s see what is Covariance.

We are going to learn what it is and when to use it.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

## Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

The goal of the exercise is to replace the `???` by a piece of code so that the exercise compiles and that’s how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (iFi9nYjrT7OfSifQngJZlw).

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala Covariance.

So, what is variance ? This is a concept related to types and how they are connected to each other. It is about inheritance. We saw before the relationship between a parent class and a child class. In functional programming we also talk about sub-type.

You can see in the start of the exercise what we encountered before related to parent and child class with inheritance.

Then we use a “normal” generic class without the covariance. You see that using a `F[A]` as a `F[B]` do not with and you are getting `type mismatch` with some explanation : `found F[A] , required F[B]`. This is expected, the types are different even tho they share a common parent, they are different.

However, why couldn’t you use a `F[A]` as a `F[P]` if `P` is the parent of `A` ? This time the error is a lot more detailed:

```type mismatch;
found   : F[A]
required: F[P]
Note: A <: P, but trait F is invariant in type A.
You may wish to define A as +A instead. (SLS 4.5)
```

We recognize one symbol we saw before: `<:` which talks about the relationship between the two types.

In the last part of the exercise you make a covariant trait using the syntax:

```trait MyTrait[+A]
```

The `+A` means that the trait is now covariant for `A`.

And now, what was failing before is working. We are able to use `F[A]` as `F[P]`.

Hope that was of help to understand what the `+A` means when you encounter it and how to solve some exception you might have seen ! See you next time.

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala Covariance.

## Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.