Scala nested case class self-bounding inheritance

Question

I'm currently working on a A* implementation in Scala. To accomplish a clean structure I would like to use a nested case class structure which implements a self-bounded trait. However, I experience some issues when implementing this in the Scala IDE. The following code will not compile:

trait A[T <: A[T]]

class B {

    case class C(int: Int) extends A[C] // A[this.C] won't work either

    def make = C(5)

}

object D {

    def foo[T <: A[T]](some: T) = {}

    val c = new B().make

    foo(c) // this does not compile

}

Is there any way I can make this structure work?

A nice explanation of path-dependent types can be found at stackoverflow.com/questions/2693067/… — manub
– manub, Commented Jan 16, 2016 at 18:10

Michael Zajac · Accepted Answer · 2016-01-16 18:06:00Z

5

Not sure why you want this, but here's why it won't work as is:

The type of D.c is B#C. It is a path-dependent type where we don't know what instance of B it belongs to. However, C extends A[C], which is the already the same as saying A[this.C] in that context, which is bound to a specific instance of B. foo sees the type parameter T as B#C, which is not the same as b.C for some b.

You have two options to make this compile.

Relax the constraints of A to B#C:

trait A[T <: A[T]]

class B {

    case class C(int: Int) extends A[B#C]

    def make = C(5)

}

object D {

    def foo[T <: A[T]](some: A[T]) = {}

    val c = new B().make

    foo(c)

}

Or handle the path-dependent type, so that c has type b.C:

trait A[T <: A[T]]

class B {

    case class C(int: Int) extends A[C]

    def make = C(5)

}

object D {

    def foo[T <: A[T]](some: A[T]) = {}

    val b = new B
    val c: b.C = b.make

    foo(c)

}

answered Jan 16, 2016 at 18:06

Michael Zajac

55.7k7 gold badges120 silver badges143 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Y4sper Over a year ago

Thanks! This explained a lot!

Joe Pallas Over a year ago

The explicit type on c in the last example isn't actually necessary, I found. I would love an explanation for why introducing the intermediate val b changes the inferred type of c. I get that there is no name for the intermediate value without b but not how that matters to the inference.

Michael Zajac Over a year ago

I don't think there is a spec for type inference rules, so I'm at a loss there. I just don't think the type inferencer is smart enough in this case to do it all in one statement--similar to why you need to curry arguments like def f(b: B)(c: b.C)

Collectives™ on Stack Overflow

Scala nested case class self-bounding inheritance

1 Answer 1

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related