You can write C <: Child[_].
Antoras
2010-10-07 23:02:26
I guess that will work, but I think the OP is after a shortcut for Parent[C < Child[Parent[C < Child[Parent[C < Child] ... etc for infinity. :)
Synesso
2010-10-07 23:39:53
As Synesso said, Child[_] won't enforce that parents and children be matched to each other.
Marcus Downing
2010-10-07 23:49:55
Why do you want to use generics? Why not using parameters: class Parent(c: Child); class Child(p: Parent)
Antoras
2010-10-08 00:25:11
@Synesso: how could you even instantiate such a hypothetical type?
pelotom
2010-10-08 03:52:01
@Antoras: I want to make sure the parent and child types are tied together, not actual instances. The question is a simplification, perhaps too far: they are actually traits that should be applied to implementing classes.
Marcus Downing
2010-10-08 07:23:51
@pelotom - with great patience.
Synesso
2010-10-12 07:28:23
+3
A:
It can be done with abstract type members.
class Parent {
type C <: Child
def child: C = null.asInstanceOf[C]
}
class Child {
type P <: Parent
def parent: P = null.asInstanceOf[P]
}
Daniel
2010-10-08 02:26:40
That gets me past the compiler warning, but doesn't enforce the condition that parent and child class must each relate to the other.
Marcus Downing
2010-10-08 07:22:23
+3
A:
You can use the approach given in http://programming-scala.labs.oreilly.com/ch13.html:
abstract class ParentChildPair {
type C <: Child
type P <: Parent
trait Child {self: C =>
def parent: P
}
trait Parent {self: P =>
def child: C
}
}
class ActualParentChildPair1 {
type C = Child1
type P = Parent1
class Child1 extends Child {...}
class Parent1 extends Parent {...}
}
Alexey Romanov
2010-10-08 07:42:55
That looks correct. Now how would you expand that to include chains of parent -> child -> child?
Marcus Downing
2010-10-08 07:46:35
This approach is successful, but I don't quite feel satisfied with it. I'm not sure I can adequately explain why.
Marcus Downing
2010-10-08 16:06:39
+2
A:
Further to @Daniel's answer, I can use an abstract type member within the child to state the generic types of the parent type like this:
trait Parent [C <: Child] {
def foo(c: C)
}
trait Child {
type P <: Parent[this.type]
def parent: P = ...
def bar = parent.foo(this)
}
this.type isn't usable directly in generics, but in a parameter it seems to be fine. This approach is a lot less long-winded than the surrounding abstract class, and allows more flexible uses such as children that are also parents.
Marcus Downing
2010-10-08 08:09:39
+1
A:
Even though it wasn't successful, I'll record this avenue as an answer.
Using abstract type members, state bounds for the types referring back to this.type:
trait Parent {
type C <: Child { type P <: this.type }
def foo(c: C)
}
trait Child {
type P <: Parent { type C <: this.type }
def parent: P
def bar = parent.foo(this)
}
class ActualParent extends Parent {
type C = ActualChild
def foo(c: ActualChild) = println("Hello")
}
class ActualChild extends Child {
type P = ActualParent
def parent = new ActualParent
}
The problem here is that the compiler doesn't connect this with the child type of the parent, so calling parent.foo(this) results in:
type mismatch
found : Child.this.type (with underlying type Child)
required: _3.C where val _3: Child.this.P
Marcus Downing
2010-10-08 14:18:59