6

So I want to have a generic trait take as a type parameter a class with a companion object that inherits from a specific base class and refer to both the companion object and the class itself. So,

abstract class BaseModel[T] {
  def all: Seq[T]
}

case class Customer(email: String, password: String)

object Customer extends BaseModel[Customer]

// This trait is my issue
trait BaseCrud[T] { 
  def table[T](f: T => String): String = {
    T.all.map(f _).mkString("")
  }
}

object Controller with BaseCrud {
  def foo = table(_.email)
}

I had some solutions to that trait that were closer but I distilled it down so you can see what I am trying to do.

Thanks

UPDATE

So I went with solution from Frank below, but I did manage to solve my initial puzzle. Though, in this case the solution was a bit ugly I'll include it here for completeness sake.

abstract class BaseModel[T] {
  def all: Seq[T] = Seq()
}

case class Customer(email: String, password: String)

object Customer extends BaseModel[Customer]

trait BaseCrud[T, U <: BaseModel[T]] { 
  def table(f: T => String)(implicit obj: U): String = {
    obj.all.map(f(_)).mkString("")
  }
}

object Controller extends BaseCrud[Customer, Customer.type] {
  implicit val model = Customer
  def foo = table(_.email)
}

So the type parameters changed to BaseCrud and the implicit was added to BaseCrud.table and implemented in Controller.model. I also fixed all my typos. I found it interesting Customer.type seems to be the type of the companion object.

gimo4000
  • 69
  • 1
  • 1
  • 4

2 Answers2

7

There's a bunch of problems in your code.. let's tackle it one after the other:

  • def table[T](... note that this T overwrites the original type parameter for the scope of the method. Not what you want really, so just omit it and make this def table(...
  • object Controller with BaseCrud { contains two more mistakes:
    1. it has to be extends not with. The latter is only used after you already extended from some base-class/trait.
    2. BaseCrud requires a type parameter that you have to specify here, so something like BaseCrud[Customer]
  • and finally, to answer your actual question: There is a huge difference between a type parameter T and a companion object. They are inherently different things, so you cannot access the companion object via T.something. Instead you need to provide the companion object in your trait in some other way, for example as an abstract field.

Here's a version of what I believe you want to do:

abstract class BaseModel[T] {
  def all: Seq[T]
}

case class Customer(email: String, password: String)

object Customer extends BaseModel[Customer] {
  def all = List[Customer]() // have to define this
}

trait BaseCrud[T] {
  val companion : BaseModel[T]
  def table(f: T => String): String = {
    companion.all.map(f).mkString("")
  }
}

object Controller extends BaseCrud[Customer] {
  val companion = Customer
  def foo = table(_.email)
}
Frank
  • 10,461
  • 2
  • 31
  • 46
  • Thanks, that got it working. Sorry about the mistakes in my code, most were caused in the stripping down for the test case. I was realizing there was a difference between companion objects and their class but couldn't work out how to pass them in as type parameters (which wasn't a very good solution). – gimo4000 May 10 '12 at 03:24
2

I think, you can use scala self type in BaseCrud trait to specify a class it should be mixed in. See linked question for details.

trait BaseCrud[T] {
  self: BaseModel[T] =>
  def table(f: T => String): String =
    all.map(f).mkString("")
}

object Controller extends BaseModel[Customer] with BaseCrud[Customer]{
  def foo = table(_.email)
}
Community
  • 1
  • 1
4e6
  • 10,696
  • 4
  • 52
  • 62
  • Thanks works but I need my BaseModel[T] mixed into the Customer object for other parts of the code. But I put this technique to use in the same code to access the Controller from the BaseCrud[T]. – gimo4000 May 10 '12 at 03:26