Optional<? extends CharSequence> x = getContent();
/*
Не компилируется с ошибкой:
incompatible types: java.lang.String cannot be converted to
capture#1 of ? extends java.lang.CharSequenc
*/
CharSequence y = x.orElse("");
// А с кастом компилируется и прекрасно работает:
// CharSequence y = ( (Optional<CharSequence>) x).orElse("");

void qsort (
    void* base,
    size_t num,
    size_t size,
    int (*comparator)(const void*, const void*)
);

class Builder {
    void addNames(String... names) {addNames(List.of(names))}
    void addNames(Iterable<String> names) {/*...*/}
}

// Метод run примает функцию из String в T и возвращает T для пустой строки.
<T> T run(Function<String, T> x) {
    return x.apply("");
}
// Метод run принимает функцию из String в ничего,
// вызывает её с пустой строкой и тоже ничего не возвращает.
void run(Consumer<String> x) {
    run(y-> {
        x.accept(y);
        return null;
        });
}
void doWork() {
    run(x-> System.out.println(x));             // Не компилируется.
    run((String x)-> System.out.println(x));    // А это компилируется кстати.
}

<T> int filterCount(Collection<T> source, Set<T> blacklist) {
    if (blacklist.isEmpty()) {
        return source.size();
    }
   return (int) source.stream().filter(x->!blacklist.contains(x)).count();
}

final class SchemaDiff {
    final String name;
    final @Nullable String oldType;
    final @Nullable String newType;
    SchemaDiff(
        String name,
        @Nullable String oldType,
        @Nullable String newType
    ) {
        this.name = name;
        this.oldType = oldType;
        this.newType = newType;
    }
    @Override
    public String toString() {
        if (oldType != null && newType != null) {
            return String.format(
                "Column %s changed the type: %s->%s",
                name,
                oldType,
                newType
            );
        }
        if (oldType == null) {
            return String.format(
                "Column %s with type %s has been added",
                name,
                newType
            );
        }
        return String.format(
            "Column %s with type %s has been removed",
            name,
            oldType
        );
    }
}

abstract class SchemaDiff {
    final String name;
    protected SchemaDiff(String name) {
        this.name = name;
    }
}
final class RemovedColumn extends SchemaDiff {
    final String type;
    RemovedColumn(String name, String type) {
        super(name);
        this.type = type;
    }
    @Override
    public String toString() {
        return String.format(
            "Column %s with type %s has been removed",
            name,
            type
        );
    }
}
final class AddedColumn extends SchemaDiff {
    final String type;
    AddedColumn(String name, String type) {
        super(name);
        this.type = type;
    }
    @Override
    public String toString() {
        return String.format(
            "Column %s with type %s has been added",
            name,
            type
        );
    }
}
final class TypeChanged extends SchemaDiff {
    final String oldType;
    final String newType;
    TypeChanged(String name, String oldType, String newType) {
        super(name);
        this.oldType = oldType;
        this.newType = newType;
    }
    @Override
    public String toString() {
        return String.format(
            "Column's %s type has been changed: %s->%s",
            name,
            oldType,
            newType
        );
    }
}

void process(List<Item> items) {
    if (isLegacy) {
        List<Legacy> docs = items.stream()
            .map(x -> toLegacy(x))
            .collect(toList);
        legacyTable.store(docs);
        logEvent(docs.stream().map(x->x.getId()).collect(toList()));
    } else {
        List<Modern> docs = items.stream()
            .map(x->toModern(x, context))
            .collect(toList);
        modernTable.store(docs);
        logEvent(docs.stream().map(x->x.getId()).collect(toList()));
    }
}

<T extends WithId> List<T> store(
    List<Item> items,
    Function<Item, T> mapper,
    Table<T> table
) {
    result = items.map(mapper).collect(toList());
    table.store(result);
    return result;
}

void process(List<Item> items) {
    List<? extends WithId> docs = isLegacy ?
        store(items, x -> toLegacy(x), legacyTable) :
        store(items, x -> toModern(x, context), modernTable);
    logEvent(docs);
}

var list = new ArrayList<>(); // К сожалению list будет иметь тип ArrayList<Object>.
list.add(1);

let mut vec = Vec::new();   // vec будет иметь тип Vec<i32>
vec.push(1);

HashMap<String, String> map = new HashMap<>();

Map<String, String> map = new HashMap<>();

Long2LongOpenHashMap createMap(long[] keys, long[] values);

Long2LongMap createMap(long[] keys, long[] values);

var map = createMap(keys, values);
for(long x: xs) {
    f(map.get(x));
}

enum FeatureType {
    ELMO,
    SLANG,
    LIFETIME_7D,
}

<TEntry extends FeatureEntry> Collection<TEntry> find(Collection<Id> ids, FeatureType type);

enum FeatureType() {
    ELMO(EmbeddingEntry.class),
    SLANG(BlacklistEntry.class),
    LIFETIME_7D(FloatEntry.class),
    ;
    private final Class<? extends FeatureEntry> entryClass;
    public FeatureType(Class<? extends FeatureEntry> entryClass) {
        this.entryClass = entryClass;
    }
    public Class<? extends FeatureEntry> getEntryClass() {
        return entryClass;
    }
}

final class FeatureType<TEntry extends FeatureEntry> {
    public static final FeatureType<EmbeddingEntry> ELMO =
        new FeatureType("elmo", EmbeddingEntry.class);
    public static final FeatureType<BlacklistEntry> SLANG =
        new FeatureType("slang", BlacklistEntry.class);
    public static final FeatureType<FloatEntry> LIFETIME_7D =
        new FeatureType("lifetime_7d", FloatEntry.class);
    private final Class<TEntry> entryClass;
    private final String name;
    private FeatureType(String name, Class<TEntry> entryClass) {
        this.name = name;
        this.entryClass = entryClass;
    }
    public String getName() {
        return name;
    }
    public Class<TEntry> getEntryClass() {
        return entryClass;
    }
}

<TEntry extends FeatureEntry> Collection<TEntry> find(
   Collection<Id> ids,
   FeatureType<TEntry> type
);

static <TLeft, TRight, TResult>
BiFunction<Optional<TLeft>, Optional<TRight>, Optional<TResult>>
lift(BiFunction<TLeft, TRight, TResult> function) {
    return (left, right) -> left.flatMap(
        leftVal -> right.map(rightVal -> function.apply(leftVal, rightVal))
    );
}

<TEntry extends FeatureEntry> Collection<TEntry> find(
    Collection<Id> ids,
    FeatureType<TEntry> type,
    Language language
);
<TEntry extends FeatureEntry> Collection<TEntry> find(
    Collection<Id> ids,
    FeatureType<TEntry> type,
    Country country
);

class FeatureType<TEntry extends FeatureEntry> {
    public static final ByLanguage<EmbeddingEntry> ELMO =
        new ByLanguage<>("elmo", EmbeddingEntry.class);
    public static final ByCountry<BlacklistEntry> SLANG =
        new ByCountry<>("slang", BlacklistEntry.class);
    public static final ByCountry<FloatEntry> LIFETIME_7D =
        new ByCountry<>("lifetime_7d", FloatEntry.class);
    private final Class<TEntry> entryClass;
    private final String name;
    private FeatureType(String name, Class<TEntry> entryClass) {
        this.name = name;
        this.entryClass = entryClass;
    }
    public String getName() {
        return name;
    }
    static final class ByLanguage<TEntry extends FeatureEntry>
        extends FeatureType<TEntry> {...}
    static final class ByCountry<TEntry extends FeatureEntry>
        extends FeatureType<TEntry> {...}
}

<TEntry extends FeatureEntry> Collection<TEntry> find(
    Collection<Id> ids,
    FeatureType.ByLanguage<TEntry> type,
    Language language
);
<TEntry extends FeatureEntry> Collection<TEntry> find(
    Collection<Id> ids,
    FeatureType.ByCountry<TEntry> type,
    Country country
);

// Код немного упрощен:
private BlendedTermQuery(Term[] terms, float[] boosts, TermStates[] contexts) {
    assert terms.length == boosts.length;
    assert terms.length == contexts.length;
    this.terms = terms;
    this.boosts = boosts;
    this.contexts = contexts;
    // Поля terms, boosts и contexts массивы с одинаковой длиной
    // Обратите внимание на пустой конструктор: все нужные нам аргументы мы захватываем.
    new InPlaceMergeSorter() {
      // Сортируем казалось бы массив terms, по крайней мере сравниваем его.
      @Override
      protected int compare(int i, int j) {
        return terms[i].compareTo(terms[j]);
      }
     // Но на самом деле мы сортируем все три массива, но по значениям из массива terms
     @Override
      protected void swap(int i, int j) {
        Term tmpTerm = terms[i];
        terms[i] = terms[j];
        terms[j] = tmpTerm;
        TermStates tmpContext = contexts[i];
        contexts[i] = contexts[j];
        contexts[j] = tmpContext;
        float tmpBoost = boosts[i];
        boosts[i] = boosts[j];
        boosts[j] = tmpBoost;
      }
    // Нет возвращаемого значения, т.к. результат функции: сайд-эффект.
    }.sort(0, terms.length);
  }

Foo(float[] boosts) {
    this.boosts = boosts.clone();
    new InPlaceMergeSorter() {
      @Override
      protected int compare(int i, int j) {
        return Float.compare(boosts[i], boosts[j]);
      }
      @Override
      protected void swap(int i, int j) {
        float tmpBoost = this.boosts[i];
        this.boosts[i] = this.boosts[j];
        this.boosts[j] = tmpBoost;
      }
    }.sort(0, terms.length);
  }