Java 8 estendere l'interfaccia di funzione e combinarli

Question

Ho un'interfaccia funzionale che estende la funzione standard jdk semplicemente ai tipi generici. Ora voglio combinare due funzioni che utilizzano andthen che sta gettando errore del compilatore

Error:(25, 25) java: method andThen in interface java.util.function.Function<T,R> cannot be applied to given types;
required: java.util.function.Function<? super ui.instrumentation.api.messaging.Message<R>,? extends V> found: ui.instrumentation.api.transformation.Transformer<T,R> reason: cannot infer type-variable(s) V (argument mismatch; ui.instrumentation.api.transformation.Transformer<T,R> cannot be converted to java.util.function.Function<? super ui.instrumentation.api.messaging.Message<R>,? extends V>)

Ecco il codice di esempio:

public interface Transformer<T,R> extends Function<Message<T>, Message<R>> { 

    static <T, R> Transformer<T, R> combine2(Transformer<T, R> first, Transformer<T, R> second) { 
     return first.andThen(second)); 
    } 
} 

C'è un modo per combinare le funzioni che si estende interfaccia funzione standard o c'è meglio modo di fare questo?

Answer 1

È necessario sia risolvere i vostri farmaci generici, e invece di usare andThen, che sarebbe tornato solo Function, si sarà meglio inlining lambda da soli:

static <T1, T2, T3> Transformer<T1, T3> combine2(Transformer<T1, T2> first, Transformer<T2, T3> second) { 
    return (Message<T1> input) -> second.apply(first.apply(input)); 
} 

Answer 2

Il primo problema è che andThen prende il valore di ritorno di una funzione e rende il tipo di parametro della funzione successiva, quindi è necessario, come spiegato da @LouisWasserman, concatenarli end-to-end con il tipo di output di uno corrispondente al tipo di input del successivo:

static <T1, T2, T3> Transformer<T1, T3> combine2(Transformer<T1, T2> first, Transformer<T2, T3> second) { 

Il secondo problema, come spiega anche, è che Function.andThen, che si sta chiamando, restituisce un Function, non uno Transformer. Notare, tuttavia, che Function e Transformer hanno la stessa forma: input singolo, uscita singola. A causa di ciò, è possibile utilizzare uno e poi adattarlo ad un altro con un riferimento metodo come questo:

static <T1, T2, T3> Transformer<T1, T3> combine(Transformer<T1, T2> first, Transformer<T2, T3> second) { 
    return first.andThen(second)::apply; 
} 

Non è necessario creare una funzione per fare questo. È possibile utilizzare la stessa tecnica chiamando direttamente Function.andThen():

Transformer<String,Integer> t1 = ... 
    Transformer<Integer,Double> t2 = ... 
    Transformer<Double,String> t3 = ... 

    Transformer<String,String> t123 = t1.andThen(t2).andThen(t3)::apply;