# 1/2- Preparing for Scala 3

I know Scala 3 is not there yet. But Dotty is, and it is getting closer and closer to be Scala 3. As a Scala developer, brace yourself to something new. Similar, yet new. And in the context of pure Functional Programming, where are we heading to ? In this article I try to show some code, to foresee the future. Spoiler: it is bright !

# The case

To get a sneak peek of a language, I often like to try to implement a small function. In this article, the goal will be to write a function which will zip elements of two linked lists with the following requirements:

- a list structure is immutable
- zipping two empty lists returns an empty list
- zipping two list of different sizes does not compile

# A possible implementation...

## Encoding a Linked List structure

Dotty aka Scala 3 brings a new `enum`

construct. This feature enables (Generalized) Algebraic Data Types ((G)ADTs). If we mimick `List`

from the standard library we can write this:

```
enum LkList[+A] {
case Cons(head: A, tail: LkList[A])
case Nil
}
```

In a way, `enum`

replaces the `sealed abstract class`

and `sealed trait`

constructs. This syntax is more concise than before.

## Encoding functor

One of the highlights of Dotty is the revamp of implicits. Today, in Scala 2, implicits have (too) many usages. Martin Odersky acknowledged this fact several times, and particularly in this talk. Dotty introduces a bunch of new keywords/syntax to address the specific case of typeclasses.

We can now define `Functor`

as such:

```
trait Functor[F[_]] {
def [A,B] (x: F[A]) map (f: A => B): F[B]
}
```

This is very similar to the Scala 2 encoding exept for one thing: the `map`

function is defined as an extension method. What it says is that the map function will be available on any instance of type `F`

given an instance of `Functor`

for it. In Scala 2, we had to provide an `implicit class`

to do this kind of extensions. Dotty removes this and adds some clarity.

Now, let's write an instance of `Functor`

for our previously defined `LkList`

.

```
package eu.enhan.fp.instances
given listFunctor as Functor[LkList] {
def [A, B] (l: LkList[A]) map (f: A => B) = l match {
case LkList.Nil => LkList.Nil
case LkList.Cons(h, t) => LkList.Cons(f(h), t.map(f))
}
}
```

Again, Dotty brings a new syntax with a `given`

keyword. in this case, we declare a named instance called `listFunctor`

which is a `Functor`

for `LkList`

. The syntax is under heavy discussion but the debates should end with a similar syntax. The key point here is that `listFunctor`

is clearly marked as a typeclass instance.

The next thing is to write a function needing a functor. Just to proof it, let's just write a function which only perform an addition to the element of a list (or any type for which we can implement `Functor`

:

```
import eu.enhan.fp.instances.given
def plus3[F[_]: Functor](l: F[Int]) = l.map(_+3)
```

Dotty allows context bounds such as Scala 2, to specify required typeclasses implementations. In this case, we are specifying that there is an instance of Functor for type `F`

for `plus3`

to compile. The assiduous reader would have notice a special import statement. In Scala 2 imports used to import all kind of definitions, including implicit instances. In dotty, a special treatment is given to `given`

instances, and we have to import them explicitly using the `import path.to.package.given`

. This ends the package object including an implicit object technique.

To explicitly summon the functor instance, we can use the `using`

keyword (since Dotty 0.22.0-RC1) !):

```
import eu.enhan.fp.instances.given
def plus2[F[_]](l: F[Int])(using FF: Functor[F]): F[Int] = l.map(_+ 2)
```

Obviously in this example, the `using`

directive is useless. Dotty comes with a function similar to `implicitly[T]`

in Scala 2. Its name is `summon[T]`

.

## Checking the size at compile time

Scala 3 will also be better at typelevel programming. We now add the size of the list as part of the type. This is a feature we find in Idris. This was already possible in Scala 2, with some libraries (such as Singleton-ops), but Dotty makes this accessible to anyone (well, everyone versed into typelevel programming). Let's adopt the same name as Idris for our sized linked list : `Vect`

.

Similarly to `LkList`

before, we are going to use enum to model the GADT:

```
import scala.compiletime.ops.int._
enum Vect[+A, S<:Int]{
case Empty extends Vect[Nothing, 0]
case Cons(h: A, t: Vect[A, S]) extends Vect[A, S + 1]
def ::[B >: A](e: B): Vect[B, S + 1] = Cons(e, this)
}
object Vect {
def apply[A](e: A): Vect[A, 1] = e :: Empty
}
```

The first line is very important: it brings in scope typelevel operators on int types. A lot of work has been done on SIP-23 to implement Singleton types (types which are inhabited by only one possible value). Dotty allows us to compute new types from existing ones. In our case, we define `Vect`

to be a type constructor with two parameters `A`

(the type of the elements in the Vect) and `S`

(the size of the Vect). Like `LkList`

we define two cases:

- an empty vector is a
`Vect`

with elements of type`Nothing`

and a size of 0 - The
`Cons`

constructor builds a new`Vect`

by prepending an element to a`Vect`

. We can see that the size type parameter is increased by one, updating the size at the typelevel.

Here is how we could use such a type:

```
val v = 4 :: 3 :: 2 :: Vect(2)
// Type of v is: Vect[Int, 4]
println(v)
// outputs : Cons(4,Cons(3,Cons(2,Cons(2,Empty))))
```

Defining the `headOption`

function to return an `Option`

corresponding to the head of the vector resulted in encountering this bug but Guillaume Martres gave me a workaround to implement this function as an extension.

```
// in companion object Vect :
def [A, S <: Int] (v: Vect[A, S]) headOption = v match {
case Empty => None
case Cons(h, t) => Some(h)
}
```

In the same way, it was easy to define a `map`

function:

```
def [A, B, S <: Int] (v: Vect[A, S]) map(f: A => B) : Vect[B, S] = v match {
case Empty => Empty
case Cons(h,t) => Cons(f(h), t.map(f))
}
```

One of the important things is that this function (via the types) guarantees that the output `Vect`

has the same size as the input `Vect`

.

Now, how to define a `Functor`

instance so that we can use the `plus3`

function defined earlier ? `Functor`

only deals with a type constructor which has only one parameter, and `Vect`

has two parameters. To solve this issue, we will use the simplified syntax for type lambdas.

```
given vectFunctor[S <: Int] as Functor[ [X] =>> Vect[X, S] ] {
def [A, B] (x: Vect[A, S]) map (f: A => B): Vect[B, S] =
Vect.map(x)(f)
}
```

The syntax is much clearer than with vanilla Scala 2 (the kind-projector plugin helped in this area), yet it still needs some explanations. Basically, we are building a parametrized given, which is the equivalent of Scala 2 `implicit def`

of some sorts... this `given`

is parametrized on `S`

and state that we can build instances for any type `X`

leading to a `Vect[X, S]`

. Then, we just write the implementation by using the already defined map function.

This leads us to using it (with some verbosity):

```
val v = 4 :: 3 :: 2 :: Vect(2)
println(plus3[[X] =>> Vect[X, 4]](vect))
// Outputs: Cons(7,Cons(6,Cons(5,Cons(5,Empty))))
```

## What's next ?

This is the end of this article. We still have plenty of things to try to solve our case:

- Make
`plus3[[X] =>> Vect[X, 4]](vect)`

to not force hardcoding the`4`

type - Fold a
`Vect`

- ...

But so far, we saw that just as is, Dotty allows to do advanced stuff. Before the follow-up article, you can checkout the code written in this article on github.