Writing a parametrized method where parameter has to be parametrized again

Question

I am working with Websockets in java. I have to implement a method that takes in a generic message handler. So I wrote like this and it compiles.

public <T, M extends MessageHandler> boolean addMessageHandler(Class<T> clazz, M messageHandler) {
}

But when I try to be more specific, it throws compile time errors.

public <T, M<T> extends MessageHandler> boolean addMessageHandler(Class<T> clazz, M<T> messageHandler) {
}

Errors I get:

Cannot resolve symbol 'T'
'>' expected.

How can I solve this issue?

The MessageHandler interface looks like this and this is a library method so I can't alter:

public interface MessageHandler {

    interface Partial<T> extends javax.websocket.MessageHandler {
        void onMessage(T messagePart, boolean last);
    }

    interface Whole<T> extends javax.websocket.MessageHandler {
        void onMessage(T message);
    }
}

You can't do this directly since Java does not have higher kinded types (i.e. `T`). You could try simulating higher kinded types via this trick I'm using here though: https://stackoverflow.com/questions/70681453/how-to-implement-fixed-points-of-functors-in-java — michid, Sep 05 '22 at 07:53
The fault lies with `MessageHandler`; it needs a type parameter that ties together the two kinds of handlers. If it were generic in T and `Partial extends MessageHandler` (and same for Whole), you'd be able to do what you want. — Brian Goetz, Sep 05 '22 at 17:01

score 1 · Answer 1 · answered Sep 06 '22 at 09:06

Java does not support this kind of composite generics. There is a workaround though:

Define a marker interface with the generic type T:
```
interface Handler<T> {}
```

Define interfaces extending the provided interfaces that cannot be changed and the marker interface:

interface PartialMessageHandler<T> extends MessageHandler.Partial<T>, 
                                           Handler<T> {}

interface WholeMessageHandler<T> extends MessageHandler.Whole<T>, 
                                         Handler<T> {}

Redefine your method like this:

public <T, M extends Handler<T>> boolean addMessageHandler(Class<T> clazz, M messageHandler) {
    return true;
}

Writing a parametrized method where parameter has to be parametrized again

1 Answers1