playing around with implicits

Implicit.scala

import MyProducers.MapProducer

trait Entity

case class Ref[T](id: String)

case class IntEntity(int: Int)
case class StringEntity(s: String)

trait RefResolver {

  private def getMap[T: MapProducer](): Map[Ref[T], T] = implicitly[MapProducer[T]].produceMap

  def getEntity[T: MapProducer](r: Ref[T]): Option[T] = getMap[T]().get(r)

}


trait ImplicitTrait{
  implicit val ip: MapProducer[Int]
  implicit val sp: MapProducer[String]
}

object Implicits extends  ImplicitTrait{
 object StringMapProducer extends MapProducer[String] {
    override def produceMap: Map[Ref[String], String] =
      Map(Ref[String]("bla") -> "stuff", Ref[String]("pina") -> "Shiraly")
  }
  object IntMapProducer extends MapProducer[Int] {
    override def produceMap =
      Map(Ref[Int]("bla") -> 42, Ref[Int]("pina") -> 43)

  }
  implicit val ip=IntMapProducer
  implicit val sp=StringMapProducer
}

trait ImplicitsWithImports{
  val implicits: ImplicitTrait
}

trait Main extends ImplicitsWithImports{
  import implicits._

  object RefResolverImpl extends RefResolver

  val stuffInt = RefResolverImpl.getEntity[Int](Ref("bla"))

  val stuffString = RefResolverImpl.getEntity[String](Ref("pina"))

  println(stuffInt)
  println(stuffString)
}

object Main2{
  object mainCoon extends Main{
    val implicits = Implicits
  }

  import mainCoon.implicits._
  mainCoon.RefResolverImpl.getEntity[Int](Ref("pina"))

}

object MyProducers {
  trait ProducerImplicits {

    implicit val sp: MapProducer[String]
    implicit val ip: MapProducer[Int]

  }
  trait MapProducer[T] {
    def produceMap: Map[Ref[T], T]
  }

}