Interaction between Lazy and tagged types

[Astrac]

There is an interaction between Lazy and tagged types with respect to the automatic derivation of typeclasses; to reproduce it this is a simple example:

sealed trait Readable[T]

object Readable {
  implicit def taggedReadable[A, T, M[_, _]](
    implicit
    r: Lazy[Readable[A]],
    ev: @@[A, T] =:= M[A, T]
  ): Readable[M[A, T]] = ???

  implicit val stringReadable: Readable[String] = ???

  implicit val hnilReadable: Readable[shapeless.HNil] = ???

  implicit def hconsReadable[H, T <: HList](
    implicit
    rh: Lazy[Readable[H]],
    rt: Readable[T]
  ): Readable[H :: T] = ???

  implicit def genericReadable[T, TGen <: HList](
    implicit
    gen: shapeless.Generic.Aux[T, TGen],
    genR: Readable[TGen]
  ): Readable[T] = ???
}

type CustomerTag = W.`'Customer`.T
type CustomerId = String @@ CustomerTag

case class Customer(id: CustomerId, name: String)

implicitly[Readable[CustomerId]]
implicitly[Readable[Customer]]

sealed trait BookTag
type BookId = String @@ BookTag

case class Book(id: BookId, title: String)

implicitly[Readable[BookId]]
implicitly[Readable[Book]]

In this case the derivation fails for both Customer and Book. Interestingly enough removing the Lazy in hconsReadable it compiles; in this case I could just remove it but when the derivation is used in third party libraries that won't compile without Lazy this could be a problem.

[milessabin]

The problem appears to be that the tags prevent the Lazy[Readable[H]] being resolved in hconsReadable.

[melrief]

I was playing with this trying to understand what is the issue and I managed to reduce the example to something smaller. I also noticed a pattern depending how you define the implicit Readable for a tagged value. I wrote both methods in this example, commented:

import shapeless._, tag._

object Main {
  sealed trait Readable[A]

  sealed trait IdTag
  type Id = String @@ IdTag

  // Method 1
  //implicit def taggedStringReadable[T]: Readable[String @@ T] = new Readable[String @@ T] { }

  // Method 2
  //implicit def taggedStringReadable[T, M[_, _]](
  //  implicit ev: @@[String, T] =:= M[String, T]): Readable[M[String, T]] = new Readable[M[String, T]] { }

  implicitly[Readable[Id]]         // always compiles
  implicitly[Strict[Readable[Id]]] // doesn't compile with 2
  implicitly[Lazy[Readable[Id]]]   // doesn't compile with 2
}

Method 1 works with Strict/Lazy and without them. Method 2 doesn't work with Strict/Lazy but works without them. The only difference seems to be that 2 needs an implicit parameter. Can that be the problem?
Anyway, I thought this could be useful to debug the problem. I will keep playing with this in the next days. @milessabin if you have an idea in which direction I should go, let me know.

[joroKr21]

My bet is on calls to dealias in LazyMacros:

  def foo[M[_, _], A, B](mab: M[A, B]) = mab
  def bar(book: Book) = {
    foo(book.id: BookId) // ok
    foo(book.id: String @@ BookTag) // ok
    foo(book.id: String with Tagged[BookTag])
    // [error]  found   : String with shapeless.tag.Tagged[LazyTagged.BookTag]
    // [error]  required: scala.collection.IndexedSeqOptimized[A,B]
    // [error]     foo(book.id: String with Tagged[BookTag])
  }

since Scala can't unify the refinement type A with Tagged[B] with the binary type constructor M[_, _]