Features Introduced In Dotty

DOTTY is a faster compiler that comes with Scala 3.
There are many new features introduced in DOTTY that are discussed further in this blog, but before reading this blog please go through the blog introduction on Dotty, to get a basic idea about dotty.

Multiversal Equality
Scala’s == and != are used to compare values of any type. This is known as universal equality that Scala uses. It is convenient to use but doesn’t guarantee type safety. Suppose there is a program in which a variable y has type T but it expects type S.

Trait Parameters
Scala 2 compiler doesn’t let the trait to have parameters. But Dotty allows the same. An example demonstrating the trait parameters is shown below:

trait Greeting(val name: String) {<br>def msg = s"How are you, $name"<br>}
<p>class C extends Greeting("Bob") { println(msg) }<br></p>

But we need to use the parameterized trait carefully. Consider the following cases:
Suppose a trait is extended twice as shown, then it will result in an error.

<br>Class D extends C with Greeting(“Bill”)<br>

Suppose a trait extends parameterized trait Greeting and there is a class E that extends the trait FormalGreeting, then we encounter an error.

<br>trait FormalGreeting extends Greeting {<br>override def msg = s"How do you do, $name"<br>} class E extends FormalGreeting //error: error: missing arguments for Greeting<br>

<br>class E extends Greeting("Bob") with FormalGreeting<br>

Inline
In the previous blog of introduction to dotty, It was mentioned that Macros are a dropped feature of Dotty. Inline modifier helps to achieve the aim of macros.

<br>object Config { inline val logging = false }<br>

Automatic Tupling of Function Parameters
Lets take an example of list,

<br>val list: List[(Int, Int)]<br>

To convert this list of tuples of Integers to list of Integers so that each pair of numbers is mapped to their sum. Previously, the best way to do this was with a pattern-matching decomposition

<br>list.map {<br>case (x, y) => x + y<br>}<br>

Now, dotty provides us to write this in this way

<br>list.map {<br>(x, y) => x + y<br>}<br>

Or,

<br>list.map(_ + _)<br>

Isn’t this more convenient, So basically a function value with more than one parameters can be converted to a function with tupled arguments if the expected type is a unary function type of the form ((T_1, …, T_n)) => U

So these were just some of the features that are provided to us by Dotty, there are many more yet to discuss and will be done in our next blog for the same.

References
https://dotty.epfl.ch/docs/