Type inference with mutually recursive generic types
 

It is possible to define mutually recursive generic types like:

interface Parent<P extends Parent<P, C>, C extends Child<P, C>>
{
Set<C> children();
}

interface Child<P extends Parent<P, C>, C extends Child<P, C>>
{
P parent();
}

Now one can write (for example):

class HumanParent implements Parent<HumanParent, HumanChild>
{
public Set<HumanChild> children() { ... }
}

class HumanChild implements Child<HumanParent, HumanChild>
{
public HumanParent parent() { ... }
}

But now I need to write a method (in some other class) like:

static <P extends Parent<P, C>, C extends Child<P, C>>
C someChildOf(P parent)
{
return parent.children().iterator().next();
}

I can use it with concrete types:

HumanParent humanParent = ...;
HumanChild humanChild = someChildOf(humanParent);

But when I try to use it with the generic wildcard type

Parent<?, ?> parent = ...;
Child<?, ?> child = someChildOf(parent); // doesn't compile

then javac complains:

<P,C>someChildOf(P) [...] cannot be applied to
(Parent<capture of ?,capture of ?>)

Is there any way to get type parameters to bind for recursive types
like Parent<?, ?> and Child<?, ?>?

Incidentally you already get the same error with just one type
parameter:

static <E extends Enum<E>> E f(E e) { ... }

Enum<?> e = null;
f(e); // doesn't compile:

<E>f(E) [...] cannot be applied to (java.lang.Enum<capture of ?>)

Of course in this case one can define f() as

static <E extends Enum<?>> E f(E e) { ... }

which compiles fine, but that's not an option with Parent/Child
because it breaks the Parent<->Child type mapping:

static <P extends Parent<?, ?>, C extends Child<?, ?>>
C someChildOf(P parent)
{
return parent.children().iterator().next(); // doesn't compile
}

incompatible types
found : Child<P,C>
required: C

Variations like

static <P extends Parent<?, C>, C extends Child<P, ?>>
C someChildOf(P parent) // doesn't compile
{
return parent.children().iterator().next();
}

type parameter C is not within its bound
type parameter P is not within its bound

obviously don't work either.

Any suggestions?

-- Niklas Matthies