Merge pull request #26 from lampepfl/dotty-0.13-mill

Release Dotty 0.13.0-RC1 for mill

Author: Aggelos Biboudis

README.md

@@ -21,13 +21,13 @@ Any version number that starts with `0.` is automatically recognized as Dotty,
 you don't need to set up anything:
 
 ```scala
-def scalaVersion = "0.12.0-RC1"
+def scalaVersion = "0.13.0-RC1"
 ```
 
 #### Nightly builds
 If the latest release of Dotty is missing a bugfix or feature you need, you may
 wish to use a nightly build. Look at the bottom of
-https://repo1.maven.org/maven2/ch/epfl/lamp/dotty_0.13/ to find the version
+https://repo1.maven.org/maven2/ch/epfl/lamp/dotty_0.14/ to find the version
 number for the latest nightly build.
 
 ## Getting your project to compile with Dotty

build.sc

@@ -2,6 +2,6 @@ import mill._, scalalib._
 
 object root extends SbtModule {
   def millSourcePath = ammonite.ops.pwd
-  def scalaVersion = "0.12.0-RC1"
+  def scalaVersion = "0.13.0-RC1"
   def publishVersion = "0.1.0"
 }

src/main/scala/AutoParamTupling.scala

@@ -1,14 +1,14 @@
 
 /**
-  * Automatic Tupling of Function Params: http://dotty.epfl.ch/docs/reference/auto-parameter-tupling.html
+  * Automatic Tupling of Function Params: https://dotty.epfl.ch/docs/reference/other-new-features/auto-parameter-tupling.html
   */
 object AutoParamTupling {
 
   def test: Unit = {
 
     /**
       * In order to get thread safety, you need to put @volatile before lazy vals.
-      * http://dotty.epfl.ch/docs/reference/changed/lazy-vals.html
+      * https://dotty.epfl.ch/docs/reference/changed-features/lazy-vals.html
       */
     @volatile lazy val xs: List[String] = List("d", "o", "t", "t", "y")
 

src/main/scala/ImplicitFunctions.scala src/main/scala/ContextQueries.scalasrc/main/scala/ImplicitFunctions.scala renamed to src/main/scala/ContextQueries.scala

@@ -3,30 +3,28 @@ import scala.concurrent.{ExecutionContext, Future}
 import scala.util.Try
 
 /**
-  * Implicit Function Types:
-  * - http://dotty.epfl.ch/docs/reference/implicit-function-types.html,
+  * Context Queries:
+  * - http://dotty.epfl.ch/docs/reference/contextual/query-types.html,
   * - https://www.scala-lang.org/blog/2016/12/07/implicit-function-types.html
   */
-object ImplicitFunctions {
+object ContextQueries /* Formerly known as Implicit Function Types */ {
 
   object context {
     // type alias Contextual
-    type Contextual[T] = implicit ExecutionContext => T
+    type Contextual[T] = given ExecutionContext => T
 
     // sum is expanded to sum(x, y)(ctx)
     def asyncSum(x: Int, y: Int): Contextual[Future[Int]] = Future(x + y)
 
-    def asyncMult(x: Int, y: Int) = { implicit ctx: ExecutionContext =>
-      Future(x * y)
-    }
+    def asyncMult(x: Int, y: Int) given (ctx: ExecutionContext) = Future(x * y)
   }
 
   object parse {
 
-    type Parseable[T] = implicit ImplicitParams.StringParser[T] => Try[T]
+    type Parseable[T] = given ImpliedInstances.StringParser[T] => Try[T]
 
     def sumStrings(x: String, y: String): Parseable[Int] = {
-      val parser = implicitly[ImplicitParams.StringParser[Int]]
+      val parser = implicitly[ImpliedInstances.StringParser[Int]]
       val tryA = parser.parse(x)
       val tryB = parser.parse(y)
 

src/main/scala/ImplicitConversion.scala src/main/scala/Conversion.scalasrc/main/scala/ImplicitConversion.scala renamed to src/main/scala/Conversion.scala

@@ -1,20 +1,20 @@
 import scala.language.implicitConversions
 
 /**
-  * Implicit Conversions: http://dotty.epfl.ch/docs/reference/changed/implicit-conversions.html
+  *  Conversions: http://dotty.epfl.ch/docs/reference/contextual/conversions.html
   */
-object ImplicitConversion {
+object Conversion {
 
   case class IntWrapper(a: Int) extends AnyVal
   case class DoubleWrapper(b: Double) extends AnyVal
 
-  def convert[T, U](x: T)(implicit converter: ImplicitConverter[T, U]): U = converter(x)
+  def convert[T, U](x: T) given (converter: Conversion[T, U]): U = converter(x)
 
-  implicit val IntWrapperToDoubleWrapper: ImplicitConverter[IntWrapper, DoubleWrapper] = new ImplicitConverter[IntWrapper, DoubleWrapper] {
+  implied IntWrapperToDoubleWrapper for Conversion[IntWrapper, DoubleWrapper] = new Conversion[IntWrapper, DoubleWrapper] {
     override def apply(i: IntWrapper): DoubleWrapper = new DoubleWrapper(i.a.toDouble)
   }
 
-  def useConversion(implicit f: ImplicitConverter[IntWrapper, DoubleWrapper]) = {
+  def useConversion given (f: Conversion[IntWrapper, DoubleWrapper]) = {
     val y: IntWrapper = new IntWrapper(4)
     val x: DoubleWrapper = y
     x

src/main/scala/EnumTypes.scala

@@ -1,5 +1,5 @@
 /**
-  * Enum Types: http://dotty.epfl.ch/docs/reference/adts.html
+  * Enum Types: http://dotty.epfl.ch/docs/reference/enums/adts.html
   */
 object EnumTypes {
 

src/main/scala/ImplicitParams.scala src/main/scala/ImpliedInstances.scalasrc/main/scala/ImplicitParams.scala renamed to src/main/scala/ImpliedInstances.scala

@@ -1,27 +1,27 @@
 import scala.util.{Success, Try}
 
 /**
-  * Implicit By-Name Parameters:
-  * - http://dotty.epfl.ch/docs/reference/implicit-by-name-parameters.html
+  * Implied Instances:
+  * - https://dotty.epfl.ch/docs/reference/contextual/instance-defs.html
   */
-object ImplicitParams {
+object ImpliedInstances {
 
   sealed trait StringParser[A] {
     def parse(s: String): Try[A]
   }
 
   object StringParser {
 
-    def apply[A](implicit parser: StringParser[A]): StringParser[A] = parser
+    def apply[A] given (parser: StringParser[A]): StringParser[A] = parser
 
     private def baseParser[A](f: String ⇒ Try[A]): StringParser[A] = new StringParser[A] {
       override def parse(s: String): Try[A] = f(s)
     }
 
-    implicit val stringParser: StringParser[String] = baseParser(Success(_))
-    implicit val intParser: StringParser[Int] = baseParser(s ⇒ Try(s.toInt))
+    implied stringParser for StringParser[String] = baseParser(Success(_))
+    implied intParser for StringParser[Int] = baseParser(s ⇒ Try(s.toInt))
 
-    implicit def optionParser[A](implicit parser: => StringParser[A]): StringParser[Option[A]] = new StringParser[Option[A]] {
+    implied optionParser[A] given (parser: => StringParser[A]) for StringParser[Option[A]] = new StringParser[Option[A]] {
       override def parse(s: String): Try[Option[A]] = s match {
         case "" ⇒ Success(None) // implicit parser not used.
         case str ⇒ parser.parse(str).map(x ⇒ Some(x)) // implicit parser is evaluated at here
@@ -34,6 +34,6 @@ object ImplicitParams {
     println(implicitly[StringParser[Option[Int]]].parse(""))
     println(implicitly[StringParser[Option[Int]]].parse("21a"))
 
-    println(implicitly[StringParser[Option[Int]]](StringParser.optionParser[Int](StringParser.intParser)).parse("42"))
+    println(implicitly[StringParser[Option[Int]]](StringParser.optionParser[Int]).parse("42"))
   }
 }

src/main/scala/IntersectionTypes.scala

@@ -1,5 +1,5 @@
 /**
-  * Intersection Types: http://dotty.epfl.ch/docs/reference/intersection-types.html
+  * Intersection Types: https://dotty.epfl.ch/docs/reference/new-types/intersection-types.html
   */
 object IntersectionTypes {
 

src/main/scala/Main.scala

@@ -7,11 +7,11 @@ object Main {
 
     runExample("Enum Types")(EnumTypes.test)
 
-    runExample("Implicit Functions")(ImplicitFunctions.test)
+    runExample("Context Queries")(ContextQueries.test)
 
-    runExample("Implicit Params")(ImplicitParams.test)
+    runExample("Implied Instances")(ImpliedInstances.test)
 
-    runExample("Implicit Conversion")(ImplicitConversion.test)
+    runExample("Conversion")(Conversion.test)
 
     runExample("Union Types")(UnionTypes.test)
 

src/main/scala/MultiversalEquality.scala

@@ -1,24 +1,24 @@
 import scala.language.strictEquality
 
 /**
-  * Multiversal Equality: http://dotty.epfl.ch/docs/reference/multiversal-equality.html
-  * scala.Eq definition: https://github.com/lampepfl/dotty/blob/master/library/src/scala/Eq.scala
+  * Multiversal Equality: https://dotty.epfl.ch/docs/reference/contextual/multiversal-equality.html
+  * scala.Eq definition: https://github.com/lampepfl/dotty/blob/master/library/src/scala/Eql.scala
   */
 object MultiversalEquality {
 
   def test: Unit = {
 
     // Values of types Int and String cannot be compared with == or !=,
-    // unless we add a custom implicit like:
-    implicit def eqIntString: Eq[Int, String] = Eq
+    // unless we add the derived implied instance like:
+    implied for Eql[Int, String] = Eql.derived
     println(3 == "3")
 
     // By default, all numbers are comparable, because of;
-    // implicit def eqNumber : Eq[Number, Number] = Eq
+    // implicit def eqlNumber: Eql[Number, Number] = derived
     println(3 == 5.1)
 
     // By default, all Sequences are comparable, because of;
-    // implicit def eqSeq[T, U](implicit eq: Eq[T, U]): Eq[Seq[T], Seq[U]] = Eq
+    // implicit def eqlSeq[T, U](implicit eq: Eql[T, U]): Eql[GenSeq[T], GenSeq[U]] = derived
     println(List(1, 2) == Vector(1, 2))
 
     class A(a: Int)
@@ -27,10 +27,10 @@ object MultiversalEquality {
     val a = new A(4)
     val b = new B(4)
 
-    // scala.language.strictEquality is enabled, therefore we need some extra implicits
+    // scala.language.strictEquality is enabled, therefore we need some extra implied instances
     // to compare instances of A and B.
-    implicit def eqAB: Eq[A, B] = Eq
-    implicit def eqBA: Eq[B, A] = Eq
+    implied for Eql[A, B] = Eql.derived
+    implied for Eql[B, A] = Eql.derived
 
     println(a != b)
     println(b == a)