Motivation

Source:

https://pbs.twimg.com/media/CthyVVWWcAAIq-a.jpg:large

Scala Matsuri¹

25 - 26 February 2017

Tokyo, Japan

Talks²:

• Dotty
• Free monads
• Scala native
• Scala.js
• and many, many more...

Notes:

[1] - http://2017.scalamatsuri.org/index_en.html

[2] - https://www.youtube.com/channel/UC6DFHglgVXQUVDbUmQHtxDQ

@scala_lang¹

1 RT = $3

1 fav = $1

... but seriously, people are excited about Dotty!

Notes:

[1] - https://twitter.com/_hhandoko/status/835764141843333121

Agenda

Source:

https://pbs.twimg.com/media/Ctd6sdMWYAEaBGX.jpg:large

Agenda

DOT and Dotty

Dotty Developer Tooling

Dropped, Implemented, and Proposed Features

Release and Timeline

Get Involved!

DOT

Source:

https://pbs.twimg.com/media/CprNb0PWEAAFS3F.jpg

DOT

• (D)ependent (O)bject (T)ypes

• A calculus of dependent object types that underlines Scala.

• Why?^1,2
  • Ensuring type soundness
  • Feedback loop for language design
  • Detect hidden connection between language features
  • Foundations are formative

Notes:

[1] - http://www.scala-lang.org/blog/2016/02/17/scaling-dot-soundness.html

[2] - https://www.youtube.com/channel/UC6DFHglgVXQUVDbUmQHtxDQ

DOT¹ (cont'd)

• vObj calculus (Odersky et al., 2003)
  • Rich type language, but unwieldly in practice
  • Subtyping lacks lower or upper bounds

• Featherweight Scala (Cremet et al., 2006)
  • Attempt at a calculus with decidable type checking

• Scalina (Moors et al., 2008)
  • Formal underpinning for introducing higher-kinded types in Scala

"A common theme among earlier systems is their complexity, which makes them hard to reason about and extend with new features."

Notes:

[1] - https://infoscience.epfl.ch/record/215280

DOT¹ (cont'd)

• Formalises System D _<:, a simple calculus for path-dependent types

• D _<: becomes a basis for a full programming language through three extensions:
  • Records
  • Type labels
  • Recursion

Notes:

[1] - https://infoscience.epfl.ch/record/215280

DOT¹ (cont'd)

• Several extensions of DOT being studied with the aim of bridging the gaps between the calculus and the programming language:
  • Type parameters
  • Variance
  • Traits
  • Classes
  • Inheritance

Notes:

[1] - https://infoscience.epfl.ch/record/215280

Dotty

Source:

https://pbs.twimg.com/media/CfSQdwUW8AErog1.jpg

Dotty¹

• New Scala compiler developed at LAMP, EPFL

• Based on DOT as a theoretical foundation

• Completely redesigned internals, familiar externals

• Its code base is almost half the size of the current nsc compiler and promises to be twice as fast

Notes:

[1] - https://www.lightbend.com/company/news/after-a-quiet-2015-martin-odersky-outlined-significant-plans-for-scala-at-scala-days-new-york

Dotty¹ (cont'd)

Notes:

[1] - https://www.infoq.com/news/2016/08/scala-development-is-heating-up

TASTY

• Typed AST serialization format
  • Introduced in scala.meta
  • Persist AST at compile time after typechecking, and load them at runtime

• One of the main targets is to become an interchange formats between the language implementing it¹

• Aims^2,3,4:
  • Compact
  • Lazy
  • Extensible
  • Precise

Notes:

[1] - https://github.com/VladimirNik/tasty

[2] - https://infoscience.epfl.ch/record/226194

[3] - https://docs.google.com/document/d/1Wp86JKpRxyWTqUU39H40ZdXOlacTNs20aTj7anZLQDw

[4] - https://docs.google.com/document/d/1h3KUMxsSSjyze05VecJGQ5H2yh7fNADtIf3chD3_wr0

scala.meta¹

• Why?²
  • Simpler
  • Fewer implementation dependencies
  • Safer, since interpretation allows sandboxing
  • Restrict syntactic freedom, since no whitebox macros³

Notes:

[1] - http://scalameta.org/

[2] - https://www.slideshare.net/Odersky/scala-days-nyc-2016

[3] - http://docs.scala-lang.org/overviews/macros/blackbox-whitebox.html

inline def m(inline x: Int, y: Float): Float =
  meta { ... }

scala.meta¹ (cont'd)

Notes:

[1] - https://www.scala-lang.org/resources/img/scalameta-sketch.jpg

Dotty Linker

• Whole program optimiser

• Making your Scala application smaller and faster
  • Leverages TASTY
  • Call-graph analysis

• What can it do?^1,2
  • Smart specialization
  • Smart dead code elimination
  • Convert classes to value classes
  • Infer more precise types
  • Eliminate virtual dispatch
  • Replace vars by vals
  • Remove duplicate vals

Notes:

[1] - https://d-d.me/talks/scaladays2015/

[2] - https://d-d.me/talks/scaladays2016-linker/#/5

Dotty Developer Tooling

Source:

https://pbs.twimg.com/media/CgGkN6YVAAAZ3_1.jpg

Getting Started

• Scastie¹, pastebin for Scala (GitHub OAuth)

• sbt-dotty² SBT plugin

• Dotty SDK (nightly) in Scala's IntelliJ IDEA³ plugin

Notes:

[1] - https://scastie.scala-lang.org/

[2] - https://github.com/lampepfl/sbt-dotty

[3] - https://www.jetbrains.com/help/idea/2017.1/getting-started-with-dotty.html

IDE Support

• IDE support using Language Server Protocol (LSP)^1,2
  • Implementation based on Eclipse LSP4J³

• Future work¹:
  • Easy startup
  • Automated testing
  • Optimisations
  • Build tool integration

Notes:

[1] - http://guillaume.martres.me/project1_report.pdf

[2] - https://github.com/Microsoft/language-server-protocol

[3] - https://github.com/eclipse/lsp4j

REPL

• Simple REPL with syntax highlighting

• Awesome error messages¹
  • Verbose explanation via -explain
  • Mistyping members
  • Type diff

Notes:

[1] - http://www.scala-lang.org/blog/2016/10/14/dotty-errors.html

Dottydoc

• A new code documentation generator^1,2

• Started as a Google Summer of Code (GSoC) 2016 project¹

• Part of this year's Scala's GSoC projects³

• Similar to Ruby's Jekyll⁴
  • Mustache templates
  • Markdown rendering
  • Ad-hoc pages
  • YAML sidebar

Notes:

[1] - https://summerofcode.withgoogle.com/archive/2016/projects/5280919451598848/

[2] - https://github.com/lampepfl/dotty/pull/1453

[3] - https://www.scala-lang.org/gsoc/2017.html

[4] - http://dotty.epfl.ch/docs/usage/dottydoc.html

Scalafix

• Scala code rewriting tool and library¹

• Helps to automate migration to future Scala versions (incl. 2.13+ and Dotty)²

• Heavy-lifting done by scala.meta

Notes:

[1] - https://scalacenter.github.io/scalafix/

[2] - http://www.scala-lang.org/blog/2016/10/24/scalafix.html

Dropped Features

Source:

https://pbs.twimg.com/media/ChJzv9lUYAA9D5E.jpg:large

(Scala 2) Macros¹

• Scala 2 macros support will be dropped

package scalaworld.macros

import scala.meta._

class Main extends scala.annotation.StaticAnnotation {
  inline def apply(defn: Any): Any = meta {
    defn match {
      case q"object $name { ..$stats }" =>
        val main = q"def main(args: Array[String]): Unit = { ..$stats }"
        q"object $name { $main }"
      case _ =>
        abort("@main must annotate an object.")
    }
  }
}

• scala.meta has support for new-style macro annotations

Notes:

[1] - http://scalameta.org/tutorial/

Procedural Syntax¹

• Procedural syntax support is no longer supported

• Use Unit returning method signature instead

object Test {
  def foo() { // procedure syntax
    ???
  }
}

Notes:

[1] - https://d-d.me/talks/scalaworld2015/

object Test {
  def foo(): Unit = {
    ???
  }
}

forSome^1,2

• forSome is no longer supported

• Use wildcards instead

Notes:

[1] - http://www.cakesolutions.net/teamblogs/2012/09/03/existential-types

[2] - https://www.reddit.com/r/scala/comments/4o36r1/what_are_the_simplifications_that_come_with_dotty/

def foo(as: Seq[A[X]] forSome { type X })

def foo(as: Seq[A[_]])

Implemented Features

Source:

https://pbs.twimg.com/media/Cf7eHZ1W4AEeZJA.jpg:large

Function Arity Adaption

• Function with very many parameters (> 22)¹
  • Uses FunctionXXL² which takes an array of params
  • Removing Tuple limitations is in the works

Notes:

[1] - https://github.com/lampepfl/dotty/pull/1758

[2] - https://github.com/lampepfl/dotty/blob/master/library/src/scala/FunctionXXL.scala

package scala

/** A function with all parameters grouped in an array. */
trait FunctionXXL {

  def apply(xs: Array[Object]): Object

  override def toString() = "<functionXXL>"
}

Intersection & Union Types¹

• Intersection types (A & B)

• Union types (A | B)
  • Scala 2 will resolve to Any
  • Dotty will resolve to its union type, e.g. Int | String

trait A { def foo: Int }
trait B { def bar: Int }

def baz(ab: A & B) = ab.foo + ab.bar

trait HasX { def x: Int }

case class A(x: Int) extends HasX
case class B(x: Int, y: Int) extends HasX

def getX(ab: A | B): Int = ab.x

Notes:

[1] - http://felixmulder.com/talks/deconstructing-dotty

Trait Parameters

• Trait parameters (SIP-25¹)
  • Scala 2 workaround using early definitions²
  • Dotty allows trait params

Notes:

[1] - http://docs.scala-lang.org/sips/pending/trait-parameters.html

[2] - http://felixmulder.com/talks/deconstructing-dotty

trait Super {
  def x: String
  println(x)
}
class Foo extends Super {
  val x = "hello"
}

new Foo // prints: null

trait Super(x: String) {
  println(x)
}
class Foo extends Super("hello")

new Foo // prints: "hello"

Others

• Fast compilation (phased fusion)^1,2

• Non-blocking lazy val (SIP20³)

• @static methods and fields⁴

• Multiversal Equality⁵

• Literal Singleton Types (SIP-23⁶)

• Pattern matching improvements:
  • Option-less pattern matching⁷
  • Exhaustivity checks

Notes:

[1] - http://felixmulder.com/talks/the-new-scala-dev-exp/#/18

[2] - https://d-d.me/talks/scalaworld2015/#/62

[3] - http://docs.scala-lang.org/sips/pending/improved-lazy-val-initialization.html

[4] - https://github.com/scala/scala.github.com/pull/491

[5] - http://www.scala-lang.org/blog/2016/05/06/multiversal-equality.html

[6] - http://docs.scala-lang.org/sips/pending/42.type.html

[7] - https://github.com/scala/scala/pull/2848

Proposed Features

Source:

https://s-media-cache-ak0.pinimg.com/564x/2c/4c/9b/2c4c9b3070518409dd3bb60866376e94.jpg

Enums¹

• Syntactic sugar with sealed trait and case classes

• Compiler will enforce necessary restrictions for interop with Java Enums.

Notes:

[1] - https://github.com/lampepfl/dotty/issues/1970

enum Color { case Red, Green, Blue }

sealed abstract class Color extends scala.Enum
object Color {
  private val $values = new scala.runtime.EnumValues[Color]
  def enumValue: Map[Int, Color] = $values.fromInt
  def enumValueNamed: Map[String, Color] = $values.fromName
  def enumValues: Iterable[Color] = $values.values

  def $new(tag: Int, name: String): Color = new Color {
    def enumTag: Int = tag
    override def toString: String = name
    $values.register(this)
  }

  final case val Red: Color = $new(0, "Red")
  final case val Green: Color = $new(1, "Green")
  final case val Blue: Color = $new(2, "Blue")
}

Non-nullable Types

• Why?²
  • Type soundness
  • Conceptually easy once we have union types and effects

Notes:

[1] - https://github.com/lampepfl/dotty/issues/1495

[2] - https://www.slideshare.net/Odersky/scala-days-nyc-2016

• Model nullable types as union types (T? = T | Null)
  • Currently null has a type of Null, which is a subtype of every non-value class¹
  • Null should be a subtype of no other type¹

Others

• Better records¹

• Effect system (with implicit)^1,2

• Generic programming support^1,3

• Implicit Functions^1,4

Notes:

[1] - https://www.slideshare.net/Odersky/scala-days-nyc-2016

[2] - https://www.reddit.com/r/scala/comments/2zff6d/effects_with_implicit_how_would_that_work/

[3] - https://github.com/lampepfl/dotty/issues/1347

[4] - https://www.scala-lang.org/blog/2016/12/07/implicit-function-types.html

Release and Timeline

Source:

https://pbs.twimg.com/media/Cg-zWsMWwAEJ-Zn.jpg:large

Release and Timeline¹

Notes:

[1] - https://www.slideshare.net/Odersky/from-dot-to-dotty

Get Involved

Source:

https://pbs.twimg.com/media/Cp6WqQdWAAEpvFt.jpg:large

Get Involved

• Dotty is on GitHub!

• Check "Open Issues" with "Help Wanted" tag
  • Docs
  • Dottydoc
  • Infrastructure
  • Reporting
  • REPL

Source:

https://github.com/lampepfl/dotty/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22