Fix hasUnknownMembers

Sometimes a computation of a superType will give NoType. Keeping with the spirit of unKnownMembers to say yes when in doubt, we should return true in this case.

The change is necessary to make the recursive call of `develop` and the call to `flatMap` in `flatten` in typeclass-encoding2.scala typecheck.

Author: odersky

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

@@ -105,6 +105,7 @@ object ProtoTypes {
     private def hasUnknownMembers(tp: Type)(implicit ctx: Context): Boolean = tp match {
       case tp: TypeVar => !tp.isInstantiated
       case tp: WildcardType => true
+      case NoType => true
       case tp: TypeRef =>
         val sym = tp.symbol
         sym == defn.NothingClass ||

tests/pos/typeclass-encoding2.scala

@@ -1,31 +1,30 @@
 /** A possible type class encoding for
 
-      trait SemiGroup {
-        def add(that: This): This
-      }
-
-      trait Monoid extends SemiGroup
-      common {
-        def unit: This
-      }
+    trait SemiGroup extends TypeClass {
+      def add(that: This): This
+    }
 
-      extension IntOps for Int : Monoid {
-        def add(that: Int) = this + that
-      }
-      common {
-        def unit = 0
-      }
+    trait Monoid extends SemiGroup
+    common {
+      def unit: This
+    }
 
-      extension StringOps for String : Monoid {
-        def add(that: Int) = this ++ that
-      }
-      common {
-        def unit = ""
-      }
+    extension IntOps for Int : Monoid {
+      def add(that: Int) = this + that
+    }
+    common {
+      def unit = 0
+    }
 
-      def sum[T: Monoid](xs: List[T]): T =
-        (instance[T, Monoid].unit /: xs)(_ `add` _)
+    extension StringOps for String : Monoid {
+      def add(that: Int) = this ++ that
+    }
+    common {
+      def unit = ""
+    }
 
+    def sum[T: Monoid](xs: List[T]): T =
+      (Monod.impl[T].unit /: xs)(_ `add` _)
 */
 object runtime {
 
@@ -40,6 +39,11 @@ object runtime {
     def inject(x: This): Instance { val common: self.type }
   }
 
+  trait TypeClassCompanion {
+    type Impl[T] <: Extension[T, _]
+    def impl[T](implicit ev: Impl[T]): Impl[T] = ev
+  }
+
   trait Extension[From, To <: TypeClass] extends TypeClassCommon {
     type This = From
     type Instance = To
@@ -54,12 +58,16 @@ import runtime._
 object semiGroups {
 
   trait SemiGroup extends TypeClass {
+    val common: SemiGroupCommon
     import common._
     def add(that: This): This
   }
   trait SemiGroupCommon extends TypeClassCommon {
     type Instance <: SemiGroup
   }
+  object SemiGroup extends TypeClassCompanion {
+    type Impl[T] = Extension[T, SemiGroup] with SemiGroupCommon
+  }
 
   trait Monoid extends SemiGroup {
     val common: MonoidCommon
@@ -69,6 +77,9 @@ object semiGroups {
     type Instance <: Monoid
     def unit: This
   }
+  object Monoid extends TypeClassCompanion {
+    type Impl[T] = Extension[T, Monoid] with MonoidCommon
+  }
 
   implicit object IntOps extends Extension[Int, Monoid] with MonoidCommon { self =>
     type This = Int
@@ -90,51 +101,51 @@ object semiGroups {
     }
   }
 
-  def sum[T](xs: List[T])(implicit $ev: Extension[T, Monoid] with MonoidCommon) =
-    (implicitly[Extension[T, Monoid] with MonoidCommon].unit /: xs)((x, y) => x `add` y)
+  def sum[T](xs: List[T])(implicit $ev: Monoid.Impl[T]) =
+    (Monoid.impl[T].unit /: xs)((x, y) => x `add` y)
 }
 
 /** Encoding for
 
-  trait Ord {
-    def compareTo(that: This): Int
-    def < (that: This) = compareTo(that) < 0
-    def > (that: This) = compareTo(that) > 0
-  }
-  common {
-    val minimum: This
-  }
+    trait Ord extends TypeClass {
+      def compareTo(that: This): Int
+      def < (that: This) = compareTo(that) < 0
+      def > (that: This) = compareTo(that) > 0
+    }
+    common {
+      val minimum: This
+    }
 
-  extension IntOrd for Int : Ord {
-    def compareTo(that: Int) =
-      if (this < that) -1 else if (this > that) +1 else 0
-  }
-  common {
-    val minimum = Int.MinValue
-  }
+    extension IntOrd for Int : Ord {
+      def compareTo(that: Int) =
+        if (this < that) -1 else if (this > that) +1 else 0
+    }
+    common {
+      val minimum = Int.MinValue
+    }
 
-  extension ListOrd[T : Ord] for List[T] : Ord {
-    def compareTo(that: List[T]): Int = (this, that) match {
-      case (Nil, Nil) => 0
-      case (Nil, _) => -1
-      case (_, Nil) => +1
-      case (x :: xs, y :: ys) =>
-        val fst = x.compareTo(y)
-        if (fst != 0) fst else xs.compareTo(ys)
+    extension ListOrd[T : Ord] for List[T] : Ord {
+      def compareTo(that: List[T]): Int = (this, that) match {
+        case (Nil, Nil) => 0
+        case (Nil, _) => -1
+        case (_, Nil) => +1
+        case (x :: xs, y :: ys) =>
+          val fst = x.compareTo(y)
+          if (fst != 0) fst else xs.compareTo(ys)
+      }
+    }
+    common {
+      val minimum = Nil
     }
-  }
-  common {
-    val minimum = Nil
-  }
 
-  def min[T: Ord](x: T, y: T) = if (x < y) x else y
+    def min[T: Ord](x: T, y: T) = if (x < y) x else y
 
-  def inf[T: Ord](xs: List[T]): T = (instance[T, Ord].minimum /: xs)(_ `min` _)
+    def inf[T: Ord](xs: List[T]): T = (Ord.impl[T].minimum /: xs)(min)
 */
-
 object ord {
 
   trait Ord extends TypeClass {
+    val common: OrdCommon
     import common._
     def compareTo(that: This): Int
     def < (that: This) = compareTo(that) < 0
@@ -144,6 +155,9 @@ object ord {
     type Instance <: Ord
     def minimum: This
   }
+  object Ord extends TypeClassCompanion {
+    type Impl[T] = Extension[T, Ord] with OrdCommon
+  }
 
   implicit object IntOrd extends Extension[Int, Ord] with OrdCommon { self =>
     type This = Int
@@ -156,7 +170,7 @@ object ord {
     }
   }
 
-  class ListOrd[T](implicit ev: Extension[T, Ord] with OrdCommon)
+  class ListOrd[T](implicit ev: Ord.Impl[T])
   extends Extension[List[T], Ord] with OrdCommon { self =>
     type This = List[T]
     type Instance = Ord
@@ -174,14 +188,123 @@ object ord {
     }
   }
 
-  implicit def listOrd[T](implicit ev: Extension[T, Ord] with OrdCommon): ListOrd[T] =
+  implicit def listOrd[T](implicit ev: Ord.Impl[T]): ListOrd[T] =
     new ListOrd[T]
 
-  def min[T](x: T, y: T)(implicit ev: Extension[T, Ord] with OrdCommon): T =
+  def min[T](x: T, y: T)(implicit ev: Ord.Impl[T]): T =
     if (x < y) x else y
 
-  def inf[T](xs: List[T])(implicit ev: Extension[T, Ord] with OrdCommon): T = {
-    val smallest = implicitly[Extension[T, Ord] with OrdCommon].minimum
-    (smallest /: xs)(min(_, _))
+  def inf[T](xs: List[T])(implicit ev: Ord.Impl[T]): T = {
+    val smallest = Ord.impl[T].minimum
+    (smallest /: xs)(min)
+  }
+}
+
+/** Encoding for
+
+    trait Functor[A] extends TypeClass1 {
+      def map[B](f: A => B): This[B]
+    }
+    common {
+      def pure[A](x: A): This[A]
+    }
+
+    // Generically, `pure[A]{.map(f)}^n`
+    def develop[A, F[X] : Functor[X]](n: Int, f: A => A): F[A] =
+      if (n == 0) Functor.impl[F].pure[A]
+      else develop[A, F](n - 1, f).map(f)
+
+    trait Monad[A] extends Functor[A] {
+      def flatMap[B](f: A => This[B]): This[B]
+      def map[B](f: A => B) = this.flatMap(f.andThen(pure))
+    }
+
+    extension ListMonad[T] for List[T] : Monad[T] {
+      static def pure[A] = Nil
+
+      def flatMap[B](f: A => List[B]): List[B] = this match {
+        case x :: xs => f(x) ++ xs.flatMap(f)
+        case Nil => Nil
+      }
+    }
+
+    extension MonadFlatten[T[X]: Monad[X]] for T[T[A]] {
+      def flatten: T[A] = this.flatMap(identity)
+    }
+*/
+object runtime1 {
+
+  trait TypeClass1 {
+    val common: TypeClassCommon1
+    type This = common.This
+  }
+
+  trait TypeClassCommon1 { self =>
+    type This[X]
+    type Instance[X] <: TypeClass1
+    def inject[A](x: This[A]): Instance[A] { val common: self.type }
+  }
+
+  trait TypeClassCompanion1 {
+    type Impl[T[_]] <: Extension1[T, _]
+    def impl[T[_]](implicit ev: Impl[T]): Impl[T] = ev
+  }
+
+  trait Extension1[From[_], To[X] <: TypeClass1] extends TypeClassCommon1 {
+    type This[X] = From[X]
+    type Instance[X] = To[X]
+  }
+
+  implicit def inject1[A, From[_]](x: From[A])
+      (implicit ev: Extension1[From, _]): ev.Instance[A] { type This = From } =
+    ev.inject(x)
+}
+import runtime1._
+
+object functors {
+
+  trait Functor[A] extends TypeClass1 {
+    val common: FunctorCommon
+    import common._
+    def map[B](f: A => B): This[B]
+  }
+  trait FunctorCommon extends TypeClassCommon1 {
+    type Instance[X] <: Functor[X]
+    def pure[A](x: A): This[A]
+  }
+  object Functor extends TypeClassCompanion1 {
+    type Impl[T[_]] = Extension1[T, Functor] with FunctorCommon
+  }
+
+  trait Monad[A] extends Functor[A] {
+    val common: MonadCommon
+    import common._
+    def flatMap[B](f: A => This[B]): This[B]
+    def map[B](f: A => B) = this.flatMap(f.andThen(common.pure))
+  }
+  trait MonadCommon extends FunctorCommon {
+    type Instance[X] <: Monad[X]
+  }
+  object Monad extends TypeClassCompanion1 {
+    type Impl[T[_]] = Extension1[T, Monad] with MonadCommon
+  }
+
+  def develop[A, F[X]](n: Int, x: A, f: A => A)(implicit ev: Functor.Impl[F]): F[A] =
+    if (n == 0) Functor.impl[F].pure(x)
+    else develop(n - 1, x, f).map(f)
+
+  implicit object ListMonad extends Extension1[List, Monad] with MonadCommon { self =>
+    type This[A] = List[A]
+    type Instance = Monad
+    def pure[A](x: A) = x :: Nil
+    def inject[A]($this: List[A]) = new Monad[A] {
+      val common: self.type = self
+      def flatMap[B](f: A => List[B]): List[B] = $this.flatMap(f)
+    }
+  }
+
+  object MonadFlatten {
+    def flatten[T[_], A]($this: T[T[A]])(implicit ev: Monad.Impl[T]): T[A] =
+      $this.flatMap(identity  )
   }
 }