The thing is primarily not in the difference of context bound vs. implicit parameter (there shouldn't be any difference (*)), the thing is that implicitly can break type of implicit found
https://typelevel.org/blog/2014/01/18/implicitly_existential.html
If you fix summon2 using custom materializer this will work as expected
def materializeFoo[T](implicit f: Foo[T]): Foo[T] { type B = f.B } = f
def summon2[T: Foo] = materializeFoo[T].value
summon2[Int]
// val res: String = Hey!
It's intersting that shapeless.the doesn't help
def summon2[T: Foo] = the[Foo[T]].value
summon2[Int]
// val res: Foo[Int]#B = Hey!
Also in Scala 2.13 you can use more general form of materializer (not specific for Foo) returning singleton type (like it's done in Scala 3)
def materialize[A](implicit f: A): f.type = f
def summon2[T: Foo] = materialize[Foo[T]].value
val y = summon2[Int]
// val res: String = Hey!
(*) Well, there is a difference that if you don't introduce parameter name f you can't refer to the type f.B explicitly in the return type. And if you don't specify return type explicitly, as we can see such type f.B can't be inferred because of the lack of a stable prefix f (see also Aux-pattern usage compiles without inferring an appropriate type).
Ah, I see. So in other words,
summon1works because there is a path to the type, via thefhandle, but insummon2there isn't. Got it 👍@gogstad note that in general (of course there are exceptions) having implicit values and methods without explicit return types is considered a bad practice. Having explicit return types can help inference and avoid introducing bugs with changes.