Are there benefits using generics in GWT - gwt

Question

Are there any benefits to the GWT compiler by using java generics in GWT. That is does it help in creating a smaller or more efficient javascript code or does it just have the same benefits as using them in Java.
The complication comes with using GWT, MVP with generics.. To implement, generics correctly the interfaces look as follows:
public interface ViewInterface<P extends PresenterInterface<? extends ViewInterface<P>>> {
}
public interface PresenterInterface<V extends ViewInterface<? extends PresenterInterface<V>>> {
}
Would code above improve the javascript compiler result or does it have no effect if I had just had the code as follows:
public interface ViewInterface<P extends PresenterInterface<?>> {
}
public interface PresenterInterface<V extends ViewInterface<?>> {
}
If there is no difference to the performance of the generated javascript the I would rather go with the second implementation. (Less Boilerplate)...
Hope this makes sense...

Answer 1

As Google I/O 2009 presentation Ray Ryan mentioned using the command pattern design when using GWT RPC. you can take a look at the presentation.there is a library called GAD a.k.a GWT Action Dispatcher where the idea is taken from the recommendation of Rayan in the presentation. GAD consists of 5 components (classes and interfaces) which uses generics. without generics it would be a lot of typecasting in the client code as well as in the server code where the Actions and Responses implementations are shared between the client and server.The 5 components i mentioned above are:
1-
public interface Action<T extends Response> extends Serializable {
}
2-
public interface ActionHandler<K extends Action, T extends Response> {
/**
* Handles the provided action and retuns response of it.
*
* #param action the action to be handled
* #return the response to be returned
*/
T handle(K action);
}
3-
public interface ActionDispatcher {
/**
* Dispatches the provided action to a proper handler that is responsible for handling of that action.
* <p/> To may dispatch the incomming action a proper handler needs to be bound
* to the {#link com.evo.gad.dispatch.ActionHandlerRepository} to may the dispatch method dispatch the
* incomming request to it.
*
* #param action the action to be handled
* #param <T> a generic response type
* #return response from the provided execution
* #throws ActionHandlerNotBoundException is thrown in cases where no handler has been bound to handle that action
*/
<T extends Response> T dispatch(Action<T> action) throws ActionHandlerNotBoundException;
}
4-
public interface ActionHandlerRepository {
ActionHandler getActionHandler(Class<? extends Action> aClass);
}
when an action is passed to the action dispatcher the action dispatcher calls the ActionHandlerRepository and asks it to get the right ActionHandler and then calls the method handle.
You can find GAD here.
In other words the benefits are quite the same. Less instanceof and typecasting.
hope this was helpful. Good Luck.