Understanding "diverging implicit expansion"

Question

Shapeless Guide provides, more or less, the following code. I changed the name from CsvEncoder to Foo.

$cat build.sbt 
scalaVersion := "2.12.1"

libraryDependencies ++= Seq(
  "com.chuusai" %% "shapeless" % "2.3.2"
)

and

$cat src/main/scala/net/Foo.scala 
package net

import shapeless.{::, Generic, HList, HNil, Lazy}

object Foo {

  def apply[A](implicit ev: Foo[A]): Foo[A] = ev

  def instance[A](f: A => List[String]): Foo[A] =
    new Foo[A] {
      override def encode(x: A): List[String] = f(x)
    }

  implicit val hnilEncoder: Foo[HNil] =
    instance[HNil](hnil => Nil)

  implicit def hlistEncoder[H, T <: HList](
    implicit hEncoder: Foo[H],
    tEncoder: Foo[T]
  ): Foo[H :: T] =
    instance[H :: T] {
      case h :: t => hEncoder.encode(h) ++ tEncoder.encode(t)
    }

  implicit def genericEncoder[A, R](
    implicit gen: Generic[A] { type Repr = R },
    enc: Foo[R]): Foo[A] =
    instance[A] { a =>
      enc.encode( gen.to(a) )
    }

}

case class Bar(baz: Int, qux: String)
case class Bippy(bar: Bar)

trait Foo[A] {
  def encode(x: A): List[String]
}

I then tried to resolve an implicit Foo[Bippy]:

> console
[info] Starting scala interpreter...
[info] 
Welcome to Scala 2.12.1 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_112).
Type in expressions for evaluation. Or try :help.

scala> import net.Foo
import net.Foo

scala> import net._
import net._

scala> implicitly[Foo[Bippy]]
<console>:16: error: diverging implicit expansion for type net.Foo[net.Bippy]
starting with method genericEncoder in object Foo
       implicitly[Foo[Bippy]]
                 ^

The text states that the following resolution steps take place before the compile-time failure:

Foo[Bippy]                 // 1
Foo[Bar :: HNil]           // 2
Foo[Bar]                   // 3
Foo[Int :: String :: HNil] // 4 uh oh

However, I don't understand the transition from 2 -> 3. Please explain.

Answer 1

Step 2 is the enc: Foo[R] in genericEncoder[Bippy, Bar :: HNil].

To resolve that it looks at hlistEncoder[Bar, HNil] which requires a hEncoder: Foo[Bar], which is step 3.