제네릭 함수와 변성

import java.util.List;
import java.util.function.Function;

public final class RawFunctionChain {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    static Object applyAll(Object input, List<Function> functions) {
        Object current = input;
        for (Function function : functions) {
            current = function.apply(current);
        }
        return current;
    }

    public static void main(String[] args) {
        Function length = (Function<String, Integer>) String::length;
        Function square = (Function<Integer, Integer>) value -> value * value;
        System.out.println(applyAll("java", List.of(length, square)));
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public final class VarianceFunctionComposition {
    sealed interface Animal permits Dog, Cat {
        String name();
    }

    record Dog(String name, int tricks) implements Animal {
    }

    record Cat(String name) implements Animal {
    }

    static <T, R> List<R> map(
            List<? extends T> source,
            Function<? super T, ? extends R> mapper) {
        List<R> result = new ArrayList<>(source.size());
        for (T value : source) {
            result.add(mapper.apply(value));
        }
        return List.copyOf(result);
    }

    static <A, B, C> Function<A, C> compose(
            Function<? super A, ? extends B> first,
            Function<? super B, ? extends C> second) {
        return value -> second.apply(first.apply(value));
    }

    public static void main(String[] args) {
        List<Dog> dogs = List.of(new Dog("Bori", 4), new Dog("Maro", 2));
        Function<Animal, String> describe = animal -> animal.getClass().getSimpleName()
                + ":" + animal.name();
        Function<CharSequence, Integer> length = CharSequence::length;
        Function<Dog, Integer> descriptionLength = compose(describe, length);

        System.out.println(map(dogs, describe));
        System.out.println(map(dogs, descriptionLength));
        System.out.println(map(List.<Animal>of(new Cat("Nabi")), describe));
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public final class GenericMethodInference {
    static <I, O> List<O> transform(List<I> source, Function<? super I, ? extends O> mapper) {
        List<O> result = new ArrayList<>();
        for (I input : source) {
            result.add(mapper.apply(input));
        }
        return List.copyOf(result);
    }

    static <T> T choose(boolean first, T left, T right) {
        return first ? left : right;
    }

    record Code(String value) {
    }

    public static void main(String[] args) {
        List<Code> codes = transform(List.of("A", "B"), Code::new);
        List<CharSequence> labels = transform(codes, code -> "code=" + code.value());
        Number inferred = choose(true, 10, 2.5);
        Number explicit = GenericMethodInference.<Number>choose(false, 10, 2.5);
        System.out.println(codes);
        System.out.println(labels);
        System.out.println(inferred.getClass().getSimpleName());
        System.out.println(explicit);
    }
}