Object type inference in Scala while implementing traits

Question

I'm working on a little generic tool, in which I need to have something like this:

An Operator trait, which will provide tools for operating elements
A Publisher trait, responsible for publishing a result represented by a Set() in the following example
A class which will implement operation traits
A companion object for this class, who will implement the publisher operations. It is mandatory for my design to keep the published results in the same trait as the publish operations

In a nutshell, I've got the following structure:

trait Publisher[A]{
  var storage: Set[A] = Set[A]()
  def publishOper(elem: A) = storage += elem
}

trait Operator[A, B]{
  def operate(elem: A): B = ???
}


object Oper extends Publisher {

}

class Oper[A, B] extends Operator[A, B]{

  def publishOper(elem: A): B = {
    val res = operate(elem)
    publishOper(res)
  }

}

But, as you can imagine, I get the following error:

publishOper(res): Type mismatch, expected: A, actual: B

This raises several questions for me:

How does type inference work when extending a companion object? (aka: Why does this happen?)
How can I solve this, while trying to keep the same structure?

class Oper[A, B] extends Operator[A, B] with Publisher[B] { ... — Rich Henry
That wouldn't work, as any class instance will have it's own storage, and publishes will not be reflected in the companion object. That's why I mentioned that it was mandatory for the design to keep them both together in the same trait. — Maximiliano Felice
They are not the same type. I think you should consider making a separate object to implement Publisher, perhaps an implicit, and pass it to each Oper instance. — Rich Henry
I.e. class Oper[A,B](implicit publisher: OperPub[B]) extends Operator[A,B] — Rich Henry
This pretty much limits the extensibility of the solution at a point I can't afford. Case classes (as you show in your response) are very restrictive. I need to keep class implementations. And, as seen, I need to access the storage unit from the companion object. — Maximiliano Felice

Rich Henry Rich Henry · Accepted Answer · 2015-02-08T01:01:09

Use a shared publisher object, perhaps via an implicit. This is actually a bit more versatile as you can control scope now. Also this is testable, using the companion object as a singleton is likely not.

implicit operPub = new Publisher[B] {
   // implementation...
}

class Oper[A, B](implicit publisher: Publisher[B]) extends Operator[A, B]{
  def publishOper(elem: A): B = {
    val res = operate(elem)
    publishOper(res)
  }
}

val a = new Oper[Int, String]
val b = new Oper[Int, String] // they both should get operPub

Object type inference in Scala while implementing traits

2 Answers