如何断言参数和结果在函数数组中是相同的类型（当作为变量时）

问：

我正在尝试编写一个可以采用任意数量的对象类 Function<> 的方法。

我想使用这些函数来映射在 InputConverter 构造函数中传递的值 <T> 并返回对象类型 R。

例：

Function<String, Integer> length = String::length;

Function<Integer, String> numOfChar = charNum->{
    StringBuilder sb = new StringBuilder();
    IntStream.generate(()->'a').limit(charNum).forEach(i -> sb.append((char) i));
    return sb.toString();
};

Function<String, String> addEnd = s->s+"FIN";

new InputConverter<String>("abc").convertBy(length, numOfChar, addEnd); //return aaaFIN

在此示例中，convertBy 必须映射： 使用 length.apply 将字符串转换为整数。使用返回的整数值通过 numOfChar.apply 将其映射到 String 类型。然后使用返回的 String，添加“FIN”并将其作为对象类型 R 返回（在本例中为 String，因为这是最后传递的函数的返回类型）。

因此，在这种情况下，convertBy 将导致 String -> String 映射，但在该方法中，函数也可以传递 String 以外的类型的值（在这种情况下，传递了 Integer）

愚蠢的方法是无限期地重载方法 convertBy：

public class InputConverter<T> {
    private final T toConvert;
 
    InputConverter(T toConvert) {
        this.toConvert = toConvert;
    }
 
 
    //stupid way nr 1
    public <R> R convertBy(Function<T,R> fun1) {
        return fun1.apply(toConvert);
    }
    //stupid way nr 2
    public <R, n1> R convertBy(Function<T,n1> fun1, Function<n1, R> fun2) {
        return fun1.andThen(fun2).apply(toConvert);
    }
    //stupid way nr 3
    public <R, n1, n2> R convertBy(Function<T,n1> fun1, Function<n1, n2> fun2, Function<n2, R> fun3) {
        return fun1.andThen(fun2).andThen(fun3).apply(toConvert);
    }
    //like that, but how do i assert that result of first funtion (fun1) type is the same type as parameter for functions[0]?
    public <R> R convertBy(Function<T, ?> fun1,Function<?,?>... functions){
        Function<T, ?> functionFin = fun1;
        for (Function<?, ?> fnIter : functions) {
            functionFin = functionFin.andThen(fnIter);
        }
        return functionFin.apply(this.toConvert);
    }
}

我希望它适用于任意数量的函数，其中第一个函数始终必须采用与构造函数中传递的相同类型的对象并返回任何类型的对象。然后第二个函数接受第一个函数返回的类型的对象，并返回任何类型的对象。然后第三个函数接受第二个函数返回的对象并返回任何类型，依此类推。
convertBy 的最终返回类型必须是上次传递的函数的返回类型。

有没有办法在不重载 convertBy 方法且无需反思的情况下解决这个问题？