Untitled

interface Task<V, R extends Result<V>> {}interface Result<V> {    V get();}class Processor {    public <V, R extends Result<V>> R process(Task<V, R> t) {        return null;    }}//---- Cooking module ----------------------------------------------------------interface CookingTask<V, R extends CookingResult<V>> extends Task<V, R> {}class CookPuddingTask implements CookingTask<PuddingValue, PuddingCookedResult> {}class CookSteakTask implements CookingTask<SteakValue, SteakCookedResult> {}interface CookingResult<V> extends Result<V> {    V accept(CookingVisitor vst);}class PuddingCookedResult implements CookingResult<PuddingValue> {    public PuddingValue get() { return null; }    public PuddingValue accept(CookingVisitor vst) { return vst.visit(this); }}class SteakCookedResult implements CookingResult<SteakValue> {    public SteakValue get() { return null; }    public SteakValue accept(CookingVisitor vst) { return vst.visit(this); }}class PuddingValue {}class SteakValue {}interface CookingVisitor {    public PuddingValue visit(PuddingCookedResult r);    public SteakValue visit(SteakCookedResult r);}class CookingClient extends AbstractProcessingClient<CookingResult> implements CookingVisitor {    CookingClient() { super(null); }        public PuddingValue cookPudding(Object data) {        CookPuddingTask task = null;        return processTask(task);    }    protected Object handleResult(CookingResult result) {        // dispatch by visitor pattern        return result.accept(this);    }      public PuddingValue visit(PuddingCookedResult r) { return r.get(); }    public SteakValue visit(SteakCookedResult r) { return r.get(); }}//---- Laundry module ----------------------------------------------------------interface LaundryTask<V, R extends LaundryResult<V>> extends Task<V, R> {}class CleanJeansTask implements LaundryTask<JeansValue, CleanJeansResult> {}class CleanTieTask implements LaundryTask<TieValue, CleanTieResult> {}interface LaundryResult<V> extends Result<V> {    V accept(LaundryVisitor vst);}class CleanJeansResult implements LaundryResult<JeansValue> {    public JeansValue get() { return null; }    public JeansValue accept(LaundryVisitor vst) { return vst.visit(this); }}class CleanTieResult implements LaundryResult<TieValue> {    public TieValue get() { return null; }    public TieValue accept(LaundryVisitor vst) { return vst.visit(this); }}class JeansValue {}class TieValue {}interface LaundryVisitor {    public JeansValue visit(CleanJeansResult r);    public TieValue visit(CleanTieResult r);}class LaundryClient extends AbstractProcessingClient<LaundryResult> implements LaundryVisitor {    LaundryClient() { super(null); }        public JeansValue cleanJeans(Object data) {        CleanJeansTask task = null;        return processTask(task);    }    protected Object handleResult(LaundryResult result) {        // dispatch by visitor pattern        return result.accept(this);    }        public JeansValue visit(CleanJeansResult r) { return r.get(); }    public TieValue visit(CleanTieResult r) { return r.get(); }}abstract class AbstractProcessingClient<V, R extends Result<? extends V>> {    Processor proc;    public AbstractProcessingClient(Processor p) { this.proc = p; }//    protected <V, R1 extends Result<V>> V processTask(Task<R1> task) {//        R result = (R)proc.process(task);//        return (V)handleResult(result);//    }    protected <V1 extends V, R1 extends R> V1 processTask(Task<V1, R1> task) {        R1 result = proc.process(task);        return handleResult(result);    }      abstract protected <V1 extends V, R1 extends R> V1 handleResult(R1 result);}