Extending the same trait with two different generic parameters

[Edmondo Porcu]

Dear All,

I would like to write a class who extend the same trait twice, with a different generic parameter.

This is not possible, what is the best way to achieve that?

Best Regards

Edmondo

[Edmondo Porcu]

Yes I realized that just after writing the email... so what is the best pattern to do that???

trait FooString extends Foo[String]

trait FooInt extends Foo[Int]

class Twice extends FooString with FooInt ?

Best Regards

2012/1/12 Matthew Pocock <turingate...@gmail.com>

Hi Edmondo,

This isn't possible. The JVM/bytecode representation of classes erases the type of generic parameters, so it wouldn't be able to tell Foo[String] from Foo[Int] appart in your implementation.

trait Foo[T] {

  def foo(t: T)

}

class Twice extends Foo[String] with Foo[Int]  // no good, as Foo[String] and Foo[Int] become Foo[_]

The way I achieve this kind of thing is to use type classes and implicits.

class Twice

trait Foo[T] {

  def foo(t: T): Unit

}

object Foo {

  implicit stringFoo: Foo[String] = new Foo[String] {

    def foo(s: String): Unit = println("Got string " + s)

  }

  

  implicit intFoo: Foo[Int] = new Foo[Int] {

    def foo(i: Int): Unit = println("Got int " + i)

  }

}

def twiceHandler[T](twice: Twice, t: T)(implicitly tFoo: Foo[T]): Unit = {

  println("In twice handler")

  tFoo.foo(t)

}

Matthew

--

Dr Matthew Pocock

Integrative Bioinformatics Group, School of Computing Science, Newcastle University

mailto: turingate...@gmail.com

gchat: turingate...@gmail.com

msn: matthew...@yahoo.co.uk

irc.freenode.net: drdozer

skype: matthew.pocock

tel: (0191) 2566550

mob: +447535664143

[Sciss]

the problem arises as you use T in any method

trait Foo[T] { def lala: T }

what would Twice return? the only possible solution would be that T is the common supertype of Int and String, then Twice would be a Foo[Any] and could faithfully return either a String or an Int from `lala`.

i ran into this problem before, too, but when you carefully think about it, the idea of inheriting a trait twice with different type arguments is flawed.

so what is it exactly that you try to achieve with Twice?

best, -sciss-

[Tom Switzer]

If you are set on it, you can use views to map Twice => Foo[Int] and Twice => Foo[String].

scala> trait Foo[T] {

     |   def bar: T

     | }

defined trait Foo

scala> case class Twice(name: String, age: Int)

defined class Twice

scala> case class TwiceFooInt(t: Twice) extends Foo[Int] {

     |   def bar = t.age

     | }

defined class TwiceFooInt

scala> case class TwiceFooString(t: Twice) extends Foo[String] {

     |   def bar = t.name

     | }

defined class TwiceFooString

scala> implicit def twice2fooInt(t: Twice) = TwiceFooInt(t)

twice2fooInt: (t: Twice)TwiceFooInt

scala> implicit def twice2fooString(t: Twice) = TwiceFooString(t)

twice2fooString: (t: Twice)TwiceFooString

scala> val a = Twice("Bob", 88)

a: Twice = Twice(Bob,88)

scala> def age(foo: Foo[Int]): Int = foo.bar

age: (foo: Foo[Int])Int

scala> age(a)

res0: Int = 88

scala> def name(foo: Foo[String]): String = foo.bar

name: (foo: Foo[String])String

scala> name(a)

res1: String = Bob

There will be problems if you, for example, 

scala> a.bar

<console>:18: error: type mismatch;

 found   : a.type (with underlying type Twice)

 required: ?{val bar: ?}

Note that implicit conversions are not applicable because they are ambiguous:

 both method twice2fooInt in object $iw of type (t: Twice)TwiceFooInt

 and method twice2fooString in object $iw of type (t: Twice)TwiceFooString

 are possible conversion functions from a.type to ?{val bar: ?}

              a.bar

[IL]

c# can do this:

class FooX : Foo<string>, Foo<Int> 

{

  public int Foo<int>.bar() { return 42; }

  public string Foo<string>.bar() { return "xyz"; }

[Sciss]

sorry, i still don't understand what you want to do.

so `MyObj` == `T` and `T` is a sealed trait with three subtypes? Do items hold only one subtype of `T`, or a mix? and what is `apply` supposed to do?

maybe if you try to formulate _what_ exactly you want to do, in plain words, without the _how_, we can try to find out what is the best _how_?

best, -sciss-

On 12 Jan 2012, at 18:48, Edmondo Porcu wrote:

> Yes it is a design flaw, which I am not able to solve.
>
> The idea is the following:
>
> I have a special collections of item , let's say
>
> class MySpecialCollection(val items:IndexedSeq[MyObj]);
>
> this will support a given method for example apply (t:T) where T<:Something.
>
> However, this T-type depends on the items inside the collection, so I cannot determine it in advance...and since T can be only of three different subclasses.... I ended up doing something like that:
>
> class MySpecialCollectionForT1 {
>
> apply(t:T1) = do smth
> apply(t:T2) = throw new UnsupportedOperationException
> apply(t:T3) = throw new UnsupportedOperationException
>
> }
>
> This is a crappy design, but I couldn't imagine anything better... so If you could help me with that I would be very happy to change it :)
>
> Best Regards
>
>
>
> 2012/1/12 Sciss <con...@sciss.de>

[edmond...@gmail.com]

Yes... You are right. Let's make an example:

There is a set of people... Each of them has a state: sad or happy.

A sad person can be guided for a city tour only by a SadGuide and a happy person can be guided only by an happy guide.

Let's say now you are a company, what would you like to do? Well... Make tours for group of people, because it's more efficient. So you create your collection of people, PeopleCollection.

If all the people are sad, you can guide all them only with a SadGuide, if they are all happy with a HappyGuide. If they differ, you can't create your PeopleCollection.

I am trying to achieve this behaviour... Now imagine to add another layer.

You have a office which groups the people , and you have to decide how many sad tours you have to organize and how many happy tours. You receive a collection of PeopleCollection from the other office, and you want to divide them. You try to collect and because of pattern matching, your collect doesn't work.

I got always stucked with erasure... In every possible implementation I imagined...

Thank you for your precious help
Edmondo
Inviato da BlackBerry(R) Wireless Handheld

[Rex Kerr]

You mean like this?

trait Mood { def smiley: String }
trait Sad extends Mood { def smiley = ":(" }
trait Happy extends Mood { def smiley = ":)" }
class PeopleCollection[A <: Mood] {
  private[this] var people: List[A] = Nil
  def who = people
  def +=(a: A) { people = a :: people }
  override def toString = people.map(_.smiley).mkString("d|"," ","|_")  // ASCII art of people in bus
}
class SadPeopleCollection extends PeopleCollection[Sad]
class HappyPeopleCollection extends PeopleCollection[Happy]
def groupByMood(ppl: Iterable[PeopleCollection[_]]) = {
  val sad = ppl.collect { case x: SadPeopleCollection => x }
  val happy = ppl.collect { case x: HappyPeopleCollection => x }
  (sad, happy)
}

// Test to paste into REPL
val sad1 = new SadPeopleCollection
sad1 += new Sad {}
sad1 += new Sad {}
val sad2 = new SadPeopleCollection
sad2 += new Sad {}
val happy1 = new HappyPeopleCollection
happy1 += new Happy {}
groupByMood( List(sad2, happy1, sad1) )

  --Rex

[Matthew Pocock]

On 12 January 2012 19:59, <edmond...@gmail.com> wrote:

Yes... You are right. Let's make an example:
 

Hi Edomondo,

I find this much easier to understand with your more fully worked example. I've not compiled any of this so...

There is a set of people... Each of them has a state: sad or happy.

sealed trait Mood

case object Happy extends Mood

case object Sad extends Mood

case class Person[M <: Mood](m: M) {

  override def toString = m match {

    case Sad => ";("

    case Happy => ":)"

  }

}

object Person {

  type SadPerson = Person[Sad]

  type HappyPerson = Person[Happy]

}

A sad person can be guided for a city tour only by a SadGuide and a happy person can be guided only by an happy guide.

trait Guide[M <: Mood] {

  def takeTour(people: Set[Person[M]])

}

trait Tour {

  def runTour()

}

class SadGuide extends Guide[Sad] {

  def takeTour(people: Set[SadPerson]) = println("To the graveyards... " + people.mkString("<8|", "|", "|8>")

}

class HappyGuide extends Guide[Happy] {

  def takeTour(people: Set[Person]) = println("To the theatres... " + people.mkString("<8|", "|", "|8>")

}

Let's say now you are a company, what would you like to do? Well... Make tours for group of people, because it's more efficient. So you create your collection of people, PeopleCollection.

type PeopleCollection[M <: Mood] = Set[Person[M]]

type SadPeople = PeopleCollection[Sad]

type HappyPeople = PeopleCollection[Happy]

 

If all the people are sad, you can guide all them only with a SadGuide, if they are all happy with a HappyGuide. If they differ, you can't create your PeopleCollection.

object TourCompany {

  def sadTour(people: SadPeople) = (new SadGuide).takeTour(people)

  def happyTour(people: HappyPeople) = (new HappyGuide).tateTour(people)

 

I am trying to achieve this behaviour... Now imagine to add another layer.

You have a office which groups the people , and you have to decide how many sad tours you have to organize and how many happy tours. You receive a collection of PeopleCollection from the other office, and you want to divide them. You try to collect and because of pattern matching, your collect doesn't work.

  def tour[M <: Mood](people: PeopleCollection[M]) = {

    val sad = people.collect { case p@Person(Sad) => p }

    val happy = people.collect { case p@Person(Happy) => p }

    sadTour(sad)

    happyTour(happy)

  }

}

 

 I got always stucked with erasure... In every possible implementation I imagined...

Thank you for your precious help

Not sure if this code compiles - I was just typing and thinking. 

Matthew