trying to typeclass

EventBus.scala

class EventBus(internal: JEventBus) {
  trait Sendable[T] {
    def send(address: String, message: T)(handler: Message[T] => Unit)
    def publish(address: String, message: T)
  }
  object Sendable {
    def instance[T](jSend: ((String, T, Handler[JMessage[T]]) => JEventBus), jPublish: (String, T) => JEventBus): Sendable[T] = new Sendable[T] {
      def publish(address: String, t: T) = {
        jPublish(address, t)
      }
      def send(address: String, t: T)(handler: Message[T] => Unit) = {
        jSend(address, t, convertFunctionToMessageHandler(handler))
      }
    }
  }

  implicit val sendableString = Sendable.instance[String](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableBoolean = Sendable.instance[Boolean](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableBuffer = Sendable.instance[Buffer](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableByte = Sendable.instance[Byte]((a, b, c) => internal.send(a, Byte.box(b), c), internal.publish(_, _))
  implicit val sendableBinary = Sendable.instance[Array[Byte]](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableChar = Sendable.instance[Char]((a, b, c) => internal.send(a, Char.box(b), c), internal.publish(_, _))
  implicit val sendableDouble = Sendable.instance[Double](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableFloat = Sendable.instance[Float]((a, b, c) => internal.send(a, Float.box(b), c), internal.publish(_, _))
  implicit val sendableInt = Sendable.instance[Int]((a, b, c) => internal.send(a, Int.box(b), c), internal.publish(_, _))
  implicit val sendableJsonArray = Sendable.instance[JsonArray](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableJsonObject = Sendable.instance[JsonObject](internal.send(_, _, _), internal.publish(_, _))
  implicit val sendableLong = Sendable.instance[Long]((a, b, c) => internal.send(a, Long.box(b), c), internal.publish(_, _))
  implicit val sendableShort = Sendable.instance[Short]((a, b, c) => internal.send(a, Short.box(b), c), internal.publish(_, _))

  def registerHandler[T <% Sendable[T]](address: String)(handler: EventBus.EventBusHandler[T], resultHandler: AsyncResult[Unit] => Unit = { ares => }): EventBus = {
    internal.registerHandler(address, handler.jHandler, voidAsyncHandler(resultHandler))
    this
  }

  def registerLocalHandler[T <% Sendable[T]](address: String)(handler: EventBus.EventBusHandler[T]): EventBus = {
    internal.registerLocalHandler(address, handler.jHandler)
    this
  }

  def unregisterHandler[T <% Sendable[T]](address: String)(handler: EventBus.EventBusHandler[T], resultHandler: AsyncResult[Unit] => Unit = { ares => }) {
    handler.unRegisterMe(internal, address, resultHandler)
  }

  def send[T](address: String, message: T)(handler: Message[T] => Unit)(implicit ev: Sendable[T]): EventBus = {
    ev.send(address, message)(handler)

    this
  }

  def publish[T](address: String, message: T)(implicit ev: Sendable[T]): EventBus = {
    ev.publish(address, message)

    this
  }

}