Derived type class instances do not seem to be eligible for extension methods

[LPTK]

See:

trait Semigroup[T] {
  def (x: T) combine (y: T): T
}
implicit val IntSemigroup: Semigroup[Int] = new {
   def (x: Int) combine (y: Int): Int = x + y
}
implicit def OptionSemigroup[T: Semigroup]: Semigroup[Option[T]] = new {
   def (x: Option[T]) combine (y: Option[T]): Option[T] = for {
     x0 <- x
     y0 <- y
   } yield x0.combine(y0)
}

This works:

scala> 1.combine(2)
val res0: Int = 3

But not this:

scala> Some(1).combine(Some(2))
1 |Some(1).combine(Some(2))
  |^^^^^^^^^^^^^^^
  |value combine is not a member of Some[Int]

not this:

scala> Option(1) combine Option(2)
1 |Option(1) combine Option(2)
  |^^^^^^^^^^^^^^^^^
  |value combine is not a member of Option[Int]

But this does:

scala> implicitly[Semigroup[Option[Int]]].combine(Some(1))(Some(2))
val res1: Option[Int] = Some(3)

[guyde2011]

This works as well:

val optSG = implicitly[Semigroup[Option[Int]]]
val some5 = {
  implicit val impSG = optSG
  Some(2) combine Some(3)
}

Implicit classes seem to not have this problem:

implicit class RichSemigrouped[SG: Semigroup](x: SG){
  def combine2(y: SG) = x combine y
}
val some5 = Some(3) combine2 Some(2) //still doesn't work
val optionInt: Option[Int] = Some(3)
val x1 = optionInt combine Some(2) // doesn't work
val x2 = optionInt combine2 Some(2) // works

[drdozer]

trait Semigroup[T] {
  def (lhs: T) append (rhs: T): T
}

object Semigroup {
  implicit object stringAppend extends Semigroup[String] {
    override def (lhs: String) append (rhs: String): String = lhs + rhs
  }

  implicit def sumSemigroup[N](implicit N: Numeric[N]): Semigroup[N] = new {
    override def (lhs: N) append (rhs: N): N = N.plus(lhs, rhs)
  }
}


object Main {
  def main(args: Array[String]): Unit = {
    import Semigroup.stringAppend // necessary to make the extension method visible
    println("Hi" append " mum")

    import Semigroup.sumSemigroup // this is not sufficient
    println(1 append 2) // this won't compile

    implicit val intSumAppend: Semigroup[Int] = sumSemigroup[Int]
    println(3 append 4) // this will
  }
}

[odersky]

This is a tough one. The problem is that, relative to implicit classes search order for the Numeric implicit is reversed.
Picking @drdozer's example:

1 append 2

will expand to

Semigroup.sumSemigroup[N](implicit N: Numeric[N])

At that point we are forced to do an implicit search which will fail with an ambiguous result, since N is not yet specified. #5836 improves the diagnostics, so this is visible now. You now get:

-- [E008] Member Not Found Error: i5773.scala:25:14 ----------------------------
25 |    println(1 append 2) // this won't compile
   |            ^^^^^^^^
   |value append is not a member of Int.
   |An extension method was tried, but could not be fully constructed:
   |
   |    Semigroup.sumSemigroup[Any](/* ambiguous */implicitly[Numeric[Any]]).append()

A possible fix would be to move the implicit from the sumSemigroup to the append method. Then it gets elaborated after seeing the first operand 1, so N is instantiated to Int before the implicit search is performed. That would have the added advantage that it's more efficient. But it does restrict what can be expressed.