import java.util.*;
import java.util.function.Function;
 
class LegacyWildcards {
    // legacy code
    private static void foo(Function<String, Number> func) {
        // ...
    }
 
    // legacy code
    private static void foo(List<Number> list) {
        // ...
    }
 
    // legacy code
    private static void foo(Comparator<Integer> comparator) {
        // ...
    }
 
    // этот метод принимает на вход функцию с:
    //  - слишком широкой областью задания
    //  и
    //  - слишком конкретным множеством значений
    @SuppressWarnings("unchecked")
    private static <T, R> Function<T, R> vary(Function<? super T, ? extends R> f0) {
        // здесь нам на руку работает type erasure:
        // f0 превратится в объект raw типа Function,
        // который кастить можно уже к чему угодно только лишь ценой warning'а
        // (а warning можно подавить)
        return (Function<T, R>) f0;
    }
 
    // кастит список вверх
    @SuppressWarnings("unchecked")
    private static <T> List<T> covary(List<? extends T> list) {
        return (List<T>) list;
    }
 
    // кастит компаратор вниз
    @SuppressWarnings("unchecked")
    private static <T> Comparator<T> contravary(Comparator<? super T> comparator) {
        return (Comparator<T>) comparator;
    }
 
    public static void main(String[] args) {
        Function<CharSequence, Integer> func = seq -> 1;
        // ошибка, потому что генерики инвариантны
        // foo(func);
 
        // сработает, потому что будут же просто передаваться
        // только строки, с которыми func значет, как справляться,
        // потому что она может справляться с любыми CharSequence
        //
        // но это выглядит не очень
        foo((Function<String, Number>)(Function<?, ?>) func);
 
        // так тоже сработает, потому что компилятор сам
        // подставит правильные типы в лямбда-выражении, но
        // это выглядит немного обскурно
        foo(func::apply);
 
        // тоже работает и немного лучше читается, потому что
        // производится явный каст
        // а ещё там есть некоторая защита, благодаря которой
        // нельзя будет сделать небезопасный каст
        foo(vary(func));
 
        // то же самое можно делать с массивами, если
        // тип, заданный в объявлении метода имеет слишком общий
        // типовый параметр
        List<Integer> intList = new ArrayList<>();
        foo(covary(intList));
 
        Comparator<Number> comparator = (n1, n2) -> 0;
        foo(contravary(comparator));
    }
}

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