CODEWITHSUNDEEP
scalatypeclassimplicit
Max
Max

Reputation: 45

Diverging implicit expansion

I have a question about implicits resolution. Say, I have the following type class:

trait Foo[In <: Base, Out <: Base] {
  def factor : Double
}

whereas

sealed trait Base
object Base {
  implicit def symmetricFoo[In <: Base, Out <: Base](implicit foo : Foo[In, Out]) : Foo[Out, In] =
    new Foo[Out, In] {
      def factor : Double = 1.0 / foo.factor
    }

  implicit def transitiveFoo[In <: Base, Mid <: Base, Out <: Base](implicit foo1 : Foo[In, Mid], foo2 : Foo[Mid, Out]) : Foo[In, Out] =
    new Foo[In, Out] {
      def factor : Double = foo1.factor * foo2.factor
    }
}

case object A extends Base

case object B extends Base {
  implicit def bFoo : Foo[B.type, A.type] =
    new Foo[B.type, A.type] {
      def factor : Double = 2.0
    }
}

case object C extends Base {
  implicit def cFoo : Foo[C.type, A.type] =
    new Foo[C.type, A.type] {
      def factor : Double = 3.0
    }
}

case object D extends Base {
  implicit def dFoo : Foo[D.type, C.type] =
    new Foo[D.type, C.type] {
      def factor : Double = 5.0
    }
}

I would like to be able to get instances of Foo[X, Y] if I have intermediary Foo's along the path from X to Y. Sometimes it does work, e. g.

println(implicitly[Foo[D.type, A.type]].factor) // 15.0 (D->C, C->A = 5 * 3)
println(implicitly[Foo[D.type, B.type]].factor) // 7.5 (D->C, C->A, A->B = 5 * 3 * 1/2)

but if I change the order of lines, it does not:

println(implicitly[Foo[D.type, B.type]].factor) // 7.5
println(implicitly[Foo[D.type, A.type]].factor) // does not compile

There are a lot of more or less identical error messages like

test.this.Base.transitiveFoo is not a valid implicit value for test.Foo[test.C.type,test.A.type] because: hasMatchingSymbol reported error: diverging implicit expansion for type test.Foo[test.C.type,Mid] starting with method transitiveFoo in object Base

diverging implicit expansion for type test.Foo[test.A.type,Mid] starting with method transitiveFoo in object Base

not enough arguments for method implicitly: (implicit e: test.Foo[test.D.type,test.A.type])test.Foo[test.D.type,test.A.type]. Unspecified value parameter e.

The full log is a bit longer.

What is the correct way, given Foo[X, Y], to get Foo[Y, X], and given Foo[X, Y] and Foo[Y, Z], to get Foo[X, Z] for any combinations of defined Foo's? Would something like shapeless' Lazy help here? Thanks in advance!

Upvotes: 2

Views: 651

Answers (1)

Dmytro Mitin
Dmytro Mitin

Reputation: 51683

This variant seems to work:

  import shapeless.Lazy

  trait Foo[In <: Base, Out <: Base] {
    def factor : Double
  }

  sealed trait Base
  case object A extends Base
  case object B extends Base
  case object C extends Base
  case object D extends Base

  trait LowPriorityImplicits {
    implicit def symmetricFoo[In <: Base, Out <: Base](implicit foo : Lazy[Foo[In, Out]]) : Foo[Out, In] =
      new Foo[Out, In] {
        def factor : Double = 1.0 / foo.value.factor
      }
  }

  object Base extends LowPriorityImplicits {
    implicit def bFoo : Foo[B.type, A.type] =
      new Foo[B.type, A.type] {
        def factor : Double = 2.0
      }

    implicit def cFoo : Foo[C.type, A.type] =
      new Foo[C.type, A.type] {
        def factor : Double = 3.0
      }

    implicit def dFoo : Foo[D.type, C.type] =
      new Foo[D.type, C.type] {
        def factor : Double = 5.0
      }

    implicit def transitiveFoo[In <: Base, Out <: Base, Mid <: Base](implicit foo1 : Foo[In, Mid], foo2 : Foo[Mid, Out]) : Foo[In, Out] =
      new Foo[In, Out] {
        def factor : Double = foo1.factor * foo2.factor
      }
  }

  def main(args: Array[String]): Unit = {
    println(implicitly[Foo[D.type, B.type]].factor) 
    println(implicitly[Foo[D.type, A.type]].factor) 
  }

  7.5
  15.0

  def main(args: Array[String]): Unit = {
    println(implicitly[Foo[D.type, A.type]].factor)
    println(implicitly[Foo[D.type, B.type]].factor)
  }

  15.0
  7.5

Just in case my build.sbt:

scalaOrganization := "org.typelevel"
scalaVersion := "2.12.3-bin-typelevel-4"
libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.2"

Upvotes: 2

Related Questions