Tenho um pequeno quebra-cabeça para um verdadeiro especialista em Java Generics ...;)

Digamos que eu tenha as duas interfaces a seguir:

interface Processor {
    void process(Foo foo);
}

interface Foo {
    Processor getProcessor();
}

e, por exemplo, as duas seguintes classes de implementação:

static class SomeProcessor implements Processor {
    static final SomeProcessor INSTANCE = new SomeProcessor();

    @Override
    public void process(Foo foo) {
        if (foo instanceof SomeFoo) { // <-- GET RID OF THIS ?
            // process ((SomeFoo) foo)
        }
    }
}

class SomeFoo implements Foo {
    @Override
    public Processor getProcessor() {
        return SomeProcessor.INSTANCE;
    }
}

Existe alguma maneira de tornar as duas interfaces genéricas de tal forma que eu não precise doinstanceof verifique noprocess() função e ainda tem a seguinte construção funcionar em outro lugar no meu código?

foo.getProcessor().process(foo);

(onde, claro, eu não sei com que subclasse de Foo estou lidando)

Em outras palavras: estou procurando uma maneira de definir uma função em um objeto, de modo que ela só possa retornar outro objeto que processe o tipo de objeto que continha a função. Nota: Não estou falando apenas do processamento de uma superclasse de pelo menos um denominador comum do objeto que contém a função (acima de: Foo), mas da classe real desse objeto (acima: SomeFoo).

(Isso não é nem de longe tão trivial quanto possa parecer, a menos que eu esteja realmente sendo idiota agora ...)