Обобщения — бесплатный тест онлайн

Вопрос 1 из 25

Какое изменение лучше всего защищает границу «Общий тип под upper bound»?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun <T> maxLength(a: T, b: T): Int where T : CharSequence =
    maxOf(a.length, b.length)

fun main() = println(maxLength("abc", StringBuilder("hello")))

Добавить локальную обработку результата, потому что будет выведено `3`: первым аргументом фиксируется тип String и второй отбрасывается. Ограничиться поясняющим комментарием о том, что возникнет ClassCastException при приведении StringBuilder к String. Формулировать минимальную границу, реально нужную алгоритму, а не привязывать функцию к конкретной реализации. Сохранить API и считать достаточным условие: Будет выведено `8`, поскольку длины складываются. Зафиксировать текущее поведение регрессионным тестом: Вызов не компилируется, потому что аргументы обязаны иметь один и тот же конкретный класс.

Вопрос 2 из 25

Где упрощённое объяснение «Проверка reified-типа» перестаёт работать?

Проверить границу полезности утверждения: Код не компилируется: оператор `is` не принимает параметры типа. Воспроизвести редкий сценарий, где оба раза будет `true`, так как Int и String наследуются от Any. Добавить граничный тест на утверждение: Оба раза будет `false`, потому что generic-типы стираются на JVM. Проверка `value is List<String>` всё равно невозможна в общем случае: reified не восстанавливает стёртые аргументы вложенного объекта. Добавить тест на состояние, при котором первый вызов завершится ClassCastException.

Вопрос 3 из 25

Какой побочный эффект существеннее остальных после правки «Smart cast после is»: Предпочитать исчерпывающую предметную модель вместо длинного каскада проверок `Any`, если набор вариантов контролируется приложением?

Smart cast убирает ручные приведения, однако широкие входы `Any` переносят ошибки модели в ветвление времени выполнения. Новый риск связан с тем, что будет выведено `other`, потому что параметр объявлен как Any. После правки останется ограничение: Возникнет ClassCastException до выбора ветви. Сопровождение усложнится, если окажется, что будет выведено `text:3`, поскольку двоеточие входит в длину x. Решение оправдано лишь при условии: Код не компилируется: smart cast работает только с локальными val.

Вопрос 4 из 25

Какой минимальный набор проверок лучше всего защищает контракт `firstOf`?

// Проследите фактическое выполнение без изменения кода.
inline fun <reified T> firstOf(values: List<Any>): T? =
    values.firstOrNull { it is T } as T?

fun main() = println(firstOf<String>(listOf(1, "ok", 2)))

Проверить совпадение в середине, отсутствие типа, первый элемент нужного типа и nullable-значения, если они допускаются входом. Полезен лишь тест, что функция компилируется; поведение `firstOrNull` уже проверено библиотекой. Нужно проверять только скорость на миллионе элементов, потому что типобезопасность гарантирована reified. Следует сравнить текст декомпилированного байткода, не выполняя функцию на данных. Достаточно одного теста со строкой в середине: остальные ветви эквивалентны компилятору.

Вопрос 5 из 25

Какой контракт снимает спор о причине поведения «Связь входного и выходного типа»?

// На ревью требуется объяснить причину поведения.
fun <T> duplicate(value: T): Pair<T, T> = value to value
fun main() = println(duplicate("kt"))

Из правил языка или API следует, что будет напечатано `(Any, Any)`, потому что generic стирает значения до выполнения. Механика примера описывается утверждением: Код не компилируется без явного `duplicate<String>`. Семантика фрагмента приводит к тому, что возникнет ClassCastException при создании Pair. Параметр типа связывает типы входов и выходов на этапе компиляции, хотя JVM-представление большинства generic-типов стирается. Причина результата в том, что будет напечатано только `kt`, так как Pair удаляет повторяющийся компонент.

Вопрос 6 из 25

Для «Проверка reified-типа» предлагают правку: Использовать reified как удобную оболочку, но предусматривать не-inline перегрузку с явным токеном типа для Java и динамических вызовов. Какой компромисс нельзя пропустить?

Главный риск формулируют так: Оба раза будет `true`, так как Int и String наследуются от Any. Reified улучшает Kotlin-вызовы, но увеличивает объём встроенного кода и создаёт менее удобную границу для Java. Граница полезности решения описывается условием: Оба раза будет `false`, потому что generic-типы стираются на JVM. После внедрения придётся исходить из того, что код не компилируется: оператор `is` не принимает параметры типа. Цена упрощения проявится, если первый вызов завершится ClassCastException.

Вопрос 7 из 25

Что появится в выводе примера «Smart cast после is»?

// Проследите фактическое выполнение без изменения кода.
fun describe(x: Any): String = when (x) {
    is String -> "text:${x.length}"
    is Int -> "int:${x + 1}"
    else -> "other"
}
fun main() = println(describe("K2"))

Будет выведено `other`, потому что параметр объявлен как Any. Будет выведено `text:3`, поскольку двоеточие входит в длину x. Код не компилируется: smart cast работает только с локальными val. Будет выведено `text:2`: после проверки `is String` переменная smart cast к String внутри ветви. Возникнет ClassCastException до выбора ветви.

Вопрос 8 из 25

На какой контракт языка или библиотеки опирается «Проверки generic-утилиты»?

// На ревью требуется объяснить причину поведения.
inline fun <reified T> firstOf(values: List<Any>): T? =
    values.firstOrNull { it is T } as T?

fun main() = println(firstOf<String>(listOf(1, "ok", 2)))

Контракт здесь понимают так: Нужно проверять только скорость на миллионе элементов, потому что типобезопасность гарантирована reified. Тест generic-утилиты должен проверять связь типов, пустой результат и границы стирания, а предупреждения unchecked cast нельзя считать доказательством корректности. Наблюдаемое поведение выводят из того, что следует сравнить текст декомпилированного байткода, не выполняя функцию на данных. Объяснение опирается на утверждение: Полезен лишь тест, что функция компилируется; поведение `firstOrNull` уже проверено библиотекой. Поведение связывают с правилом: Достаточно одного теста со строкой в середине: остальные ветви эквивалентны компилятору.

Вопрос 9 из 25

Как сделать ответственность во фрагменте «Связь входного и выходного типа» понятной следующему разработчику?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun <T> duplicate(value: T): Pair<T, T> = value to value
fun main() = println(duplicate("kt"))

Спрятать участок за вспомогательной функцией, сохранив предположение: Код не компилируется без явного `duplicate<String>`. Оставить реализацию без изменений и закрепить тестом предположение: Возникнет ClassCastException при создании Pair. Использовать параметр типа только там, где между значениями есть реальная связь; иначе более честен конкретный тип или `Any` с явной проверкой. Ограничиться поясняющим комментарием о том, что будет напечатано `(Any, Any)`, потому что generic стирает значения до выполнения. Добавить защитную проверку перед фрагментом, поскольку будет напечатано только `kt`, так как Pair удаляет повторяющийся компонент.

Вопрос 10 из 25

Какой редкий случай способен сломать наивную трактовку «Общий тип под upper bound»?

Зафиксировать сценарий, где ожидается: Вызов не компилируется, потому что аргументы обязаны иметь один и тот же конкретный класс. Проверить, сохраняется ли контракт, когда будет выведено `3`: первым аргументом фиксируется тип String и второй отбрасывается. Отдельно воспроизвести случай, в котором возникнет ClassCastException при приведении StringBuilder к String. Добавить граничный тест на утверждение: Будет выведено `8`, поскольку длины складываются. При нескольких аргументах компилятор может вывести их общий супертип в пределах ограничения, поэтому точный `T` бывает шире каждого аргумента.

Вопрос 11 из 25

Какое объяснение результата «Smart cast после is» выдерживает проверку соседними случаями?

// На ревью требуется объяснить причину поведения.
fun describe(x: Any): String = when (x) {
    is String -> "text:${x.length}"
    is Int -> "int:${x + 1}"
    else -> "other"
}
fun main() = println(describe("K2"))

Механика примера описывается утверждением: Код не компилируется: smart cast работает только с локальными val. Из правил языка или API следует, что будет выведено `other`, потому что параметр объявлен как Any. Причина результата в том, что будет выведено `text:3`, поскольку двоеточие входит в длину x. Проверка `is` и control-flow анализ сужают тип в области, где компилятор доказал условие и стабильность значения. Семантика фрагмента приводит к тому, что возникнет ClassCastException до выбора ветви.

Вопрос 12 из 25

Какая правка устраняет причину риска в «Проверки generic-утилиты», а не только его проявление?

// Сохраните назначение фрагмента, но укрепите его контракт.
inline fun <reified T> firstOf(values: List<Any>): T? =
    values.firstOrNull { it is T } as T?

fun main() = println(firstOf<String>(listOf(1, "ok", 2)))

Убрать ненужный cast через `filterIsInstance<T>().firstOrNull()` либо локализовать его и доказать инвариант тестами. Перенести проверку в вызывающий код, исходя из того, что нужно проверять только скорость на миллионе элементов, потому что типобезопасность гарантирована reified. Вынести участок в отдельный метод, считая верным следующее: Следует сравнить текст декомпилированного байткода, не выполняя функцию на данных. Спрятать участок за вспомогательной функцией, сохранив предположение: Достаточно одного теста со строкой в середине: остальные ветви эквивалентны компилятору. Оставить реализацию без изменений и закрепить тестом предположение: Полезен лишь тест, что функция компилируется; поведение `firstOrNull` уже проверено библиотекой.

Вопрос 13 из 25

На каком входе или состоянии граница «Связь входного и выходного типа» становится заметной?

Параметр типа без ограничений предоставляет только операции `Any?`, поэтому попытка вызвать предметный метод не компилируется. Считать опасной границей ситуацию, где код не компилируется без явного `duplicate<String>`. Зафиксировать сценарий, где ожидается: Будет напечатано только `kt`, так как Pair удаляет повторяющийся компонент. Добавить регрессию на гипотезу: Будет напечатано `(Any, Any)`, потому что generic стирает значения до выполнения. Проверить, сохраняется ли контракт, когда возникнет ClassCastException при создании Pair.

Вопрос 14 из 25

В «Общий тип под upper bound» выбрали решение: Формулировать минимальную границу, реально нужную алгоритму, а не привязывать функцию к конкретной реализации. Какова его реальная цена?

Главный риск формулируют так: Возникнет ClassCastException при приведении StringBuilder к String. Главная цена решения — необходимость учитывать, что будет выведено `8`, поскольку длины складываются. Сопровождение усложнится, если окажется, что вызов не компилируется, потому что аргументы обязаны иметь один и тот же конкретный класс. Узкая граница даёт больше доступных операций, но уменьшает повторное использование и способна протащить лишнюю зависимость. После правки останется ограничение: Будет выведено `3`: первым аргументом фиксируется тип String и второй отбрасывается.

Вопрос 15 из 25

Какие значения будут выведены?

// Проследите фактическое выполнение без изменения кода.
inline fun <reified T> Any?.isType(): Boolean = this is T
fun main() {
    println(42.isType<Int>())
    println(42.isType<String>())
}

Код не компилируется: оператор `is` не принимает параметры типа. Оба раза будет `false`, потому что generic-типы стираются на JVM. Первый вызов завершится ClassCastException. Будут выведены `true` и `false`: reified-параметр подставляет проверяемый тип в inline-вызов. Оба раза будет `true`, так как Int и String наследуются от Any.

Вопрос 16 из 25

Какой контрпример точнее всего показывает границу «Проверки generic-утилиты»?

Отдельно воспроизвести случай, в котором нужно проверять только скорость на миллионе элементов, потому что типобезопасность гарантирована reified. Список с объектом `List<Int>` нельзя надёжно отличить от `List<String>` через одну reified-проверку внешнего типа. Воспроизвести редкий сценарий, где полезен лишь тест, что функция компилируется; поведение `firstOrNull` уже проверено библиотекой. Проверить границу полезности утверждения: Следует сравнить текст декомпилированного байткода, не выполняя функцию на данных. Добавить граничный тест на утверждение: Достаточно одного теста со строкой в середине: остальные ветви эквивалентны компилятору.

Вопрос 17 из 25

Какой побочный эффект существеннее остальных после правки «Связь входного и выходного типа»: Использовать параметр типа только там, где между значениями есть реальная связь; иначе более честен конкретный тип или `Any` с явной проверкой?

Новый риск связан с тем, что будет напечатано `(Any, Any)`, потому что generic стирает значения до выполнения. Generic-код устраняет дублирование и сохраняет типы, но сложные параметры ухудшают сообщения компилятора и читаемость API. После правки останется ограничение: Возникнет ClassCastException при создании Pair. Обратная сторона изменения состоит в том, что код не компилируется без явного `duplicate<String>`. Сопровождение усложнится, если окажется, что будет напечатано только `kt`, так как Pair удаляет повторяющийся компонент.

Вопрос 18 из 25

Почему вызов компилируется и что он выведет?

// Проследите фактическое выполнение без изменения кода.
fun <T> maxLength(a: T, b: T): Int where T : CharSequence =
    maxOf(a.length, b.length)

fun main() = println(maxLength("abc", StringBuilder("hello")))

Оба аргумента имеют общий допустимый тип `CharSequence`; функция выведет `5`. Будет выведено `3`: первым аргументом фиксируется тип String и второй отбрасывается. Возникнет ClassCastException при приведении StringBuilder к String. Будет выведено `8`, поскольку длины складываются. Вызов не компилируется, потому что аргументы обязаны иметь один и тот же конкретный класс.

Вопрос 19 из 25

Какое объяснение результата «Проверка reified-типа» выдерживает проверку соседними случаями?

// На ревью требуется объяснить причину поведения.
inline fun <reified T> Any?.isType(): Boolean = this is T
fun main() {
    println(42.isType<Int>())
    println(42.isType<String>())
}

Такой результат объясняют тем, что оба раза будет `false`, потому что generic-типы стираются на JVM. Из правил языка или API следует, что оба раза будет `true`, так как Int и String наследуются от Any. Семантика фрагмента приводит к тому, что первый вызов завершится ClassCastException. Механика примера описывается утверждением: Код не компилируется: оператор `is` не принимает параметры типа. `reified` допустим у параметра inline-функции и позволяет применять `is`, `as`, `T::class` без отдельного `Class`/`KClass` аргумента.

Вопрос 20 из 25

Что изменить в «Smart cast после is», чтобы скрытое допущение стало явным контрактом?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun describe(x: Any): String = when (x) {
    is String -> "text:${x.length}"
    is Int -> "int:${x + 1}"
    else -> "other"
}
fun main() = println(describe("K2"))

Оставить реализацию без изменений и закрепить тестом предположение: Код не компилируется: smart cast работает только с локальными val. Оставить структуру прежней, документировав утверждение: Возникнет ClassCastException до выбора ветви. Вынести участок в отдельный метод, считая верным следующее: Будет выведено `text:3`, поскольку двоеточие входит в длину x. Предпочитать исчерпывающую предметную модель вместо длинного каскада проверок `Any`, если набор вариантов контролируется приложением. Перенести проверку в вызывающий код, исходя из того, что будет выведено `other`, потому что параметр объявлен как Any.

Вопрос 21 из 25

Что выведет фрагмент «Связь входного и выходного типа»?

// Проследите фактическое выполнение без изменения кода.
fun <T> duplicate(value: T): Pair<T, T> = value to value
fun main() = println(duplicate("kt"))

Код не компилируется без явного `duplicate<String>`. Будет напечатано только `kt`, так как Pair удаляет повторяющийся компонент. Возникнет ClassCastException при создании Pair. Будет напечатано `(Any, Any)`, потому что generic стирает значения до выполнения. Будет напечатано `(kt, kt)`: тип `T` выводится как `String` и сохраняется в обоих компонентах пары.

Вопрос 22 из 25

Какое правило определяет поведение фрагмента «Общий тип под upper bound»?

// На ревью требуется объяснить причину поведения.
fun <T> maxLength(a: T, b: T): Int where T : CharSequence =
    maxOf(a.length, b.length)

fun main() = println(maxLength("abc", StringBuilder("hello")))

Причину поведения формулируют так: Возникнет ClassCastException при приведении StringBuilder к String. Upper bound ограничивает допустимые типы и открывает членам функции API границы; несколько границ задаются через `where`. Контракт здесь понимают так: Будет выведено `8`, поскольку длины складываются. Поведение связывают с правилом: Будет выведено `3`: первым аргументом фиксируется тип String и второй отбрасывается. Причина результата в том, что вызов не компилируется, потому что аргументы обязаны иметь один и тот же конкретный класс.

Вопрос 23 из 25

Какое изменение лучше всего защищает границу «Проверка reified-типа»?

// Сохраните назначение фрагмента, но укрепите его контракт.
inline fun <reified T> Any?.isType(): Boolean = this is T
fun main() {
    println(42.isType<Int>())
    println(42.isType<String>())
}

Использовать reified как удобную оболочку, но предусматривать не-inline перегрузку с явным токеном типа для Java и динамических вызовов. Сохранить API и считать достаточным условие: Код не компилируется: оператор `is` не принимает параметры типа. Ограничиться поясняющим комментарием о том, что первый вызов завершится ClassCastException. Зафиксировать текущее поведение регрессионным тестом: Оба раза будет `true`, так как Int и String наследуются от Any. Передать ответственность владельцу вызова, предполагая, что оба раза будет `false`, потому что generic-типы стираются на JVM.

Вопрос 24 из 25

Какой пограничный сценарий обязательно добавить к проверкам «Smart cast после is»?

Проверить соседний случай: Возникнет ClassCastException до выбора ветви. Воспроизвести редкий сценарий, где код не компилируется: smart cast работает только с локальными val. Отдельно воспроизвести случай, в котором будет выведено `other`, потому что параметр объявлен как Any. Проверить границу полезности утверждения: Будет выведено `text:3`, поскольку двоеточие входит в длину x. Из-за стирания можно проверить `x is List<*>`, но не доказать через `is`, что каждый элемент является String.

Вопрос 25 из 25

Что станет новой точкой внимания после изменения «Проверки generic-утилиты»: Убрать ненужный cast через `filterIsInstance<T>().firstOrNull()` либо локализовать его и доказать инвариант тестами?

После внедрения придётся исходить из того, что достаточно одного теста со строкой в середине: остальные ветви эквивалентны компилятору. Практическое ограничение подхода: Полезен лишь тест, что функция компилируется; поведение `firstOrNull` уже проверено библиотекой. Цена упрощения проявится, если нужно проверять только скорость на миллионе элементов, потому что типобезопасность гарантирована reified. Компромисс состоит в утверждении: Следует сравнить текст декомпилированного байткода, не выполняя функцию на данных. Высокоуровневые библиотечные операции яснее, но ручной проход может быть быстрее; решение принимают по профилированию, а не по длине кода.