Перегрузка общих неявных преобразований

Question

У меня небольшая проблема с scala (версия 2.8.0RC1) с неявными преобразованиями. При импорте более одного неявного преобразования первое становится затененным. Вот код, где появляется проблема:

// containers
class Maybe[T]
case class Nothing[T]() extends Maybe[T]
case class Just[T](value: T) extends Maybe[T]

case class Value[T](value: T)

trait Monad[C[_]] {
  def >>=[A, B](a: C[A], f: A => C[B]): C[B]
  def pure[A](a: A): C[A]
}

// implicit converter
trait Extender[C[_]] {
  class Wrapper[A](c: C[A]) {
    def >>=[B](f: A => C[B])(implicit m: Monad[C]): C[B] = {
      m >>= (c, f)
    }

    def >>[B](b: C[B])(implicit m: Monad[C]): C[B] = {
      m >>= (c, { (x: A) => b } )
    }
  }

  implicit def extendToMonad[A](c: C[A]) = new Wrapper[A](c)
}

// instance maybe
object maybemonad extends Extender[Maybe] {
  implicit object MaybeMonad extends Monad[Maybe] {
    override def >>=[A, B](a: Maybe[A], f: A => Maybe[B]): Maybe[B] = {
      a match {
        case Just(x) => f(x)
        case Nothing() => Nothing()
      }
    }

    override def pure[A](a: A): Maybe[A] = Just(a)
  }
}

// instance value
object identitymonad extends Extender[Value] {
  implicit object IdentityMonad extends Monad[Value] {
    override def >>=[A, B](a: Value[A], f: A => Value[B]): Value[B] = {
      a match {
        case Value(x) => f(x)
      }
    }

    override def pure[A](a: A): Value[A] = Value(a)
  }
}

import maybemonad._
//import identitymonad._

object Main {
  def main(args: Array[String]): Unit = {
    println(Just(1) >>= { (x: Int) => MaybeMonad.pure(x) })
  }
}

При раскомментировании второго оператора импорта все идет не так, как первый "exteToMonad" затеняется.

Однако этот работает:

object Main {
  implicit def foo(a: Int) = new  {
    def foobar(): Unit = { 
      println("Foobar")
    }   
  }

  implicit def foo(a: String) = new  {
    def foobar(): Unit = { 
      println(a)
    }   
  }

  def main(args: Array[String]): Unit = { 
    1 foobar()
    "bla" foobar()
  }
}

Так, где подвох? Чего мне не хватает?

С уважением, raichoo

Answer 1

Действительно, привязки и импортированные привязки скрываются по имени. Это в равной степени относится и к импортированным неявным преобразованиям.

Я считаю, что вы можете переименовать во время импорта в качестве обходного пути:

import IdentityMonad.{extendToMonad => extendToMonadIdentity}
import MaybeMonad.{extendToMonad => extendToMonadMaybe}

Возможно, вы захотите взглянуть на Scalaz, в частности scalaz.{Functor, Scalaz, MA}, чтобы найти другой способ кодирования этих классов типов. В частности, при поиске класса типов Monad[X] выполняется поиск сопутствующего объекта Monad.

Answer 2

я думаю, что компилятор считает

implicit object IdentityMonad extends Monad[Value] 

более конкретно, чем

implicit object MaybeMonad extends Monad[Maybe]

как часть процесса разрешения. Даниэль опубликовал статью, которая освещает эту проблему здесь . Во втором примере вызовы разрешают неявное напрямую по типу, и указанное правило разрешения не требуется.