Question

Given this code:

  trait S {
    def s: String
  }

  trait I {
    def i: Int
  }

  case class CC_S(s: String) extends S
  case class CC_I(i: Int) extends I
  case class CC_S_I(s: String, i: Int) extends S with I

  def combine(s: S, i: I): S with I = CC_S_I(s.s, i.i)

This test succeeds:

Assert.assertEquals(CC_S_I("s", 1), combine(CC_S("s"), CC_I(1)))

(How) can I make the combine method generic as a trait with type parameters? I.e. I would like to define something like this:

  trait MyTrait[A,B] {
    def combine(a: A, b: B): A with B
  }

So that I can use it like this:

  class MyClass[A <: CC_S, B <: CC_I] extends MyTrait[A,B] {
    override def combine(s: A, i: B) = CC_S_I(s.s, i.i) //Note: this line does not compile...
  }

  Assert.assertEquals(CC_S_I("s", 1), new MyClass().combine(CC_S("s"), CC_I(1)))

Update. This would have been a better example:

  class MyClass[A <: S, B <: I] extends MyTrait[A,B] {
    override def combine(s: A, i: B) = CC_S_I(s.s, i.i) //Note: this line does not compile...
  }

See comments under Travis’s answer to see that answered as well.

Answer 1

The problem is just that CC_S_I isn’t actually a subtype of either CC_S or CC_I (although it is a subtype of S and I). The following will work:

class MyClass extends MyTrait[S, I] {
  def combine(s: S, i: I): S with I = CC_S_I(s.s, i.i)
}

---

As a side note, the Shapeless library is worth looking into if you’re doing much of this kind of thing. It allows you to write your combine method very generically:

import shapeless._

def combine[A, B, C, AL <: HList, BL <: HList, CL <: HList](a: A, b: B)(implicit
  aIso: Iso[A, AL],
  bIso: Iso[B, BL],
  cIso: Iso[C, CL],
  p: PrependAux[AL, BL, CL]
): C = cIso from p(aIso to a, bIso to b)

Now you just need a bit of boilerplate:

implicit val ccsIso = Iso.hlist(CC_S.apply _, CC_S.unapply _)
implicit val cciIso = Iso.hlist(CC_I.apply _, CC_I.unapply _)
implicit val ccsiIso = Iso.hlist(CC_S_I.apply _, CC_S_I.unapply _)

And you can write:

scala> val x = combine[
     |   CC_S, CC_I, CC_S_I, String :: HNil, Int :: HNil, String :: Int :: HNil
     | ](CC_S("s"), CC_I(1))
x: CC_S_I = CC_S_I(s,1)

The enormous type annotation is unfortunately necessary with this formulation, but this should give you some idea of what’s possible, and there are things you could do to make the usage cleaner.