Add Any-kinded types

Allow a form of type polymorphism by adding an AnyKind upper bound.

Types of any kind are subtypes of `AnyKind`. The "any-kinded types" are `AnyKind` itself, and all type
parameters and abstract types having it as an upper bound.

Any-kinded types cannot be used as types of values, nor can they be applied to type parameters. About the
only thing one can do with them is use them as parameters for implicit searches.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -304,6 +304,9 @@ class Definitions {
     def ObjectMethods = List(Object_eq, Object_ne, Object_synchronized, Object_clone,
         Object_finalize, Object_notify, Object_notifyAll, Object_wait, Object_waitL, Object_waitLI)
 
+  lazy val AnyKindClass =  completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyKind, AbstractFinal, Nil))
+  def AnyKindType = AnyKindClass.typeRef
+
   /** Marker method to indicate an argument to a call-by-name parameter.
    *  Created by byNameClosures and elimByName, eliminated by Erasure,
    */
@@ -1158,6 +1161,7 @@ class Definitions {
   lazy val syntheticScalaClasses = List(
     AnyClass,
     AnyRefAlias,
+    AnyKindClass,
     RepeatedParamClass,
     ByNameParamClass2x,
     AnyValClass,

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -196,6 +196,7 @@ object StdNames {
     final val REIFY_TYPECREATOR_PREFIX: N       = "$typecreator"
 
     final val Any: N                 = "Any"
+    final val AnyKind: N             = "AnyKind"
     final val AnyVal: N              = "AnyVal"
     final val ExprApi: N             = "ExprApi"
     final val Mirror: N              = "Mirror"

compiler/src/dotty/tools/dotc/core/TypeApplications.scala

@@ -207,12 +207,17 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => Nil
   }
 
-  /** Is self type higher-kinded (i.e. of kind != "*")? */
+  /** Is self type higher-kinded (i.e. of kind != "*")
+   *  or any-kinded (i.e. has AnyKind as upper bound)?
+   */
   def isHK(implicit ctx: Context): Boolean = hkResult.exists
 
-  /** If self type is higher-kinded, its result type, otherwise NoType */
+  /** If self type is higher-kinded, its result type, otherwise NoType.
+   *  Note: The hkResult of an any-kinded type is again AnyKind.
+   */
   def hkResult(implicit ctx: Context): Type = self.dealias match {
-    case self: TypeRef => self.info.hkResult
+    case self: TypeRef =>
+      if (self.symbol == defn.AnyKindClass) self else self.info.hkResult
     case self: AppliedType =>
       if (self.tycon.typeSymbol.isClass) NoType else self.superType.hkResult
     case self: HKTypeLambda => self.resultType
@@ -226,17 +231,24 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => NoType
   }
 
-  /** Do self and other have the same kinds (not counting bounds and variances) */
+  /** Do self and other have the same kinds (not counting bounds and variances)?
+   *  Note: An any-kinded type "has the same kind" as any other type.
+   */
   def hasSameKindAs(other: Type)(implicit ctx: Context): Boolean = {
-    // println(i"check kind $self $other") // DEBUG
+    def isAnyKind(tp: Type) = tp match {
+      case tp: TypeRef => tp.symbol == defn.AnyKindClass
+      case _ => false
+    }
     val selfResult = self.hkResult
     val otherResult = other.hkResult
-    if (selfResult.exists)
-      otherResult.exists &&
-      selfResult.hasSameKindAs(otherResult) &&
-      self.typeParams.corresponds(other.typeParams)((sparam, oparam) =>
-        sparam.paramInfo.hasSameKindAs(oparam.paramInfo))
-    else !otherResult.exists
+    isAnyKind(selfResult) || isAnyKind(otherResult) ||
+    { if (selfResult.exists)
+        otherResult.exists &&
+        selfResult.hasSameKindAs(otherResult) &&
+        self.typeParams.corresponds(other.typeParams)((sparam, oparam) =>
+          sparam.paramInfo.hasSameKindAs(oparam.paramInfo))
+      else !otherResult.exists
+    }
   }
 
   /** Dealias type if it can be done without forcing the TypeRef's info */

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -48,16 +48,22 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   private[this] var totalCount = 0
 
   private[this] var myAnyClass: ClassSymbol = null
+  private[this] var myAnyKindClass: ClassSymbol = null
   private[this] var myNothingClass: ClassSymbol = null
   private[this] var myNullClass: ClassSymbol = null
   private[this] var myObjectClass: ClassSymbol = null
   private[this] var myAnyType: TypeRef = null
+  private[this] var myAnyKindType: TypeRef = null
   private[this] var myNothingType: TypeRef = null
 
   def AnyClass = {
     if (myAnyClass == null) myAnyClass = defn.AnyClass
     myAnyClass
   }
+  def AnyKindClass = {
+    if (myAnyKindClass == null) myAnyKindClass = defn.AnyKindClass
+    myAnyKindClass
+  }
   def NothingClass = {
     if (myNothingClass == null) myNothingClass = defn.NothingClass
     myNothingClass
@@ -74,6 +80,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myAnyType == null) myAnyType = AnyClass.typeRef
     myAnyType
   }
+  def AnyKindType = {
+    if (myAnyKindType == null) myAnyKindType = AnyKindClass.typeRef
+    myAnyKindType
+  }
   def NothingType = {
     if (myNothingType == null) myNothingType = NothingClass.typeRef
     myNothingType
@@ -367,8 +377,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       case _ =>
         val cls2 = tp2.symbol
         if (cls2.isClass) {
-          if (cls2.typeParams.nonEmpty && tp1.isHK)
-            recur(tp1, EtaExpansion(cls2.typeRef))
+          if (cls2 eq AnyKindClass)
+            return true
           else {
             val base = tp1.baseType(cls2)
             if (base.exists) {
@@ -540,7 +550,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         def compareTypeBounds = tp1 match {
           case tp1 @ TypeBounds(lo1, hi1) =>
             ((lo2 eq NothingType) || isSubType(lo2, lo1)) &&
-            ((hi2 eq AnyType) || isSubType(hi1, hi2))
+            ((hi2 eq AnyType) || (hi2 eq AnyKindType) || isSubType(hi1, hi2))
           case tp1: ClassInfo =>
             tp2 contains tp1
           case _ =>
@@ -1216,8 +1226,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (tp1 eq tp2) tp1
     else if (!tp1.exists) tp2
     else if (!tp2.exists) tp1
-    else if ((tp1 isRef AnyClass) || (tp2 isRef NothingClass)) tp2
-    else if ((tp2 isRef AnyClass) || (tp1 isRef NothingClass)) tp1
+    else if ((tp1 isRef AnyClass) || (tp1 isRef AnyKindClass) || (tp2 isRef NothingClass)) tp2
+    else if ((tp2 isRef AnyClass) || (tp2 isRef AnyKindClass) || (tp1 isRef NothingClass)) tp1
     else tp2 match {  // normalize to disjunctive normal form if possible.
       case OrType(tp21, tp22) =>
         tp1 & tp21 | tp1 & tp22
@@ -1265,8 +1275,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (tp1 eq tp2) tp1
     else if (!tp1.exists) tp1
     else if (!tp2.exists) tp2
-    else if ((tp1 isRef AnyClass) || (tp2 isRef NothingClass)) tp1
-    else if ((tp2 isRef AnyClass) || (tp1 isRef NothingClass)) tp2
+    else if ((tp1 isRef AnyClass) || (tp1 isRef AnyKindClass) || (tp2 isRef NothingClass)) tp1
+    else if ((tp2 isRef AnyClass) || (tp2 isRef AnyKindClass) || (tp1 isRef NothingClass)) tp2
     else {
       val t1 = mergeIfSuper(tp1, tp2, canConstrain)
       if (t1.exists) t1

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1462,7 +1462,9 @@ object messages {
 
   case class MissingTypeParameterFor(tpe: Type)(implicit ctx: Context)
     extends Message(MissingTypeParameterForID) {
-    val msg = hl"missing type parameter for ${tpe}"
+    val msg =
+      if (tpe.derivesFrom(defn.AnyKindClass)) hl"${tpe} cannot be used as a value type"
+      else hl"missing type parameter for ${tpe}"
     val kind = "Syntax"
     val explanation = ""
   }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2147,7 +2147,7 @@ class Typer extends Namer
 
     def adaptNoArgsImplicitMethod(wtp: MethodType): Tree = {
       assert(wtp.isImplicitMethod)
-      val tvarsToInstantiate = tvarsInParams(tree, locked)
+      val tvarsToInstantiate = tvarsInParams(tree, locked).distinct
       wtp.paramInfos.foreach(instantiateSelected(_, tvarsToInstantiate))
       val constr = ctx.typerState.constraint
 

tests/neg/anykind.scala

@@ -0,0 +1,23 @@
+object AnyKinds {
+
+  val x: AnyKind = 2   // error
+
+  def f[X <: AnyKind]: Any = {
+    type T0 = AnyKind[String] // error
+    type T1 = X[Int]  // error
+    type T2 = X { type F = Int } // error
+    val x: X = ???   // error
+  }
+
+  f[Int]      // OK
+  f[[X] => X] // OK
+  f[Nothing]  // OK
+
+  def g[X <: Any]: Any = {
+    f[X]      // OK
+  }
+  g[Int]      // OK
+  g[Nothing]  // OK
+
+
+}

tests/neg/anykind2.scala

@@ -0,0 +1,20 @@
+object AnyKinds {
+
+  def f[X <: AnyKind]: Any = {
+    g[X]             // error
+    g[AnyKind]       // error
+  }
+
+  f[Int]      // OK
+  f[[X] => X] // OK
+  f[Nothing]  // OK
+
+  def g[X <: Any]: Any = {
+    f[X]      // OK
+  }
+  g[Int]      // OK
+  g[List]     // error
+  g[Nothing]  // OK
+
+
+}

tests/pos/kindPolySemiGroup.scala

@@ -0,0 +1,85 @@
+// Adapted from github:mandubian/kind-polymorphic-semigroup.scala
+sealed trait HList
+case class HCons[+HD, +TL](hd: HD, tl: TL) extends HList
+case object HNil extends HList
+
+object Test {
+
+  type HNil = HNil.type
+
+  // Kind Extractor
+  trait Kinder[MA] { type M <: AnyKind }
+  object Kinder extends KinderLowerImplicits {
+    type Aux[MA, M0 <: AnyKind] = Kinder[MA] { type M = M0 }
+
+    implicit def kinder1[M0[_], A0]: Kinder.Aux[M0[A0], M0] =
+      new Kinder[M0[A0]] { type M[t] = M0[t] }
+    implicit def kinder2[M0[_, _], A0, B0]: Kinder.Aux[M0[A0, B0], M0] =
+      new Kinder[M0[A0, B0]] { type M[t, u] = M0[t, u]; type Args = HCons[A0, HCons[B0, HNil]] }
+  }
+  trait KinderLowerImplicits {
+    implicit def kinder0[A]: Kinder.Aux[A, A] = new Kinder[A] { type M = A; type Args = HNil }
+  }
+
+  // Kind Polymorphic Semigroup using shapeless "Polymorphic function"-style
+  trait SemiGroup[M <: AnyKind] {
+    // Just a mirror type of itself to ensure the owning of AppendFunction...
+    type Self
+    // the function accepting only monomorphic type MA allowed by this scoped Semigroup AppendFunction
+    def append[MA](m1: MA, m2: MA)(implicit appender: SemiGroup.AppendFunction[Self, MA, M]) = appender(m1, m2)
+  }
+
+  object SemiGroup {
+    type Aux[M <: AnyKind, Self0] = SemiGroup[M] { type Self = Self0 }
+
+    // the monomorphic append function (yes we need to reify monomorphic types sometimes)
+    trait AppendFunction[P, FA, F <: AnyKind] {
+      def apply(m1: FA, m2: FA): FA
+    }
+  }
+
+  // Int SemiGroup instance
+  implicit object SemiGroupInt extends SemiGroup[Int] {
+    type Self = this.type
+    implicit val appender: SemiGroup.AppendFunction[Self, Int, Int]= new SemiGroup.AppendFunction[Self, Int, Int] {
+      def apply(m1: Int, m2: Int) = m1 + m2
+    }
+  }
+
+  // List SemiGroup instance
+  implicit object SemiGroupList extends SemiGroup[List] {
+    type Self = this.type
+    implicit def appender[A]: SemiGroup.AppendFunction[Self, List[A], List] = new  {
+      def apply(m1: List[A], m2: List[A]) = m1 ++ m2
+    }
+  }
+
+  // Map SemiGroup instance
+  implicit object SemiGroupMap extends SemiGroup[Map] {
+    type Self = this.type
+    implicit def appender[A, B]: SemiGroup.AppendFunction[Self, Map[A, B], Map] = new {
+      def apply(m1: Map[A, B], m2: Map[A, B]) = m1 ++ m2
+    }
+  }
+
+  // Searching a semigroup and using it
+  def semiGroup[M <: AnyKind](implicit sg: SemiGroup[M]): SemiGroup.Aux[M, sg.Self] = sg
+
+  semiGroup[Int].append(5, 8)
+  semiGroup[List].append(List(1), List(3))
+  semiGroup[Map].append(Map("toto" -> 1L), Map("tata" -> 3L))
+
+  // higher level append function
+  def append[MA, M <: AnyKind, Self](m1: MA, m2: MA)(
+    implicit kinder: Kinder.Aux[MA, M], semiGroup: SemiGroup.Aux[M, Self], appender: SemiGroup.AppendFunction[Self, MA, M]
+  ): MA = semiGroup.append(m1, m2)
+
+  import SemiGroupList.appender
+  import SemiGroupMap.appender
+
+  val r1: Int = append(5, 8)
+
+  // TODO: Figure igure out why `M` below cannot be inferred
+  val r2: List[Int] = append[M = List](List(1), List(3))
+  val r3: Map[String, Long] = append[M = Map](Map("toto" -> 1L), Map("tata" -> 3L))
+}