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

Вопрос 1 из 20

Какой вывод о теме «Параметры типов» можно сделать без дополнительных допущений?

def first[A](xs: List[A]): Option[A] = xs.headOption
println(first(List(1,2,3)))

Контекстный параметр выбирается по имени значения; его точный тип и область импорта при поиске не учитываются. Контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа. Расширение типа до супертипа всегда сохраняет самый специализированный given и доступные extension-методы. Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений.

Вопрос 2 из 20

Для темы «Параметры типов» какое последствие нельзя исключить одним успешным запуском?

// Дополнительный контекст: Библиотечный тип расширили, и в месте вызова изменился выбор доступных операций и контекстных значений.
def first[A](xs: List[A]): Option[A] = xs.headOption
println(first(List(1,2,3)))

Стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Стирание параметра типа на JVM автоматически компенсируется наличием любого подходящего `given`. Пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Сложный тип может ухудшить только время компиляции; публичная совместимость и понятность ошибок от него не зависят. Метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек.

Вопрос 3 из 20

При исправлении темы «Параметры типов» какая правка сохраняет полезную семантику и не расширяет обещания API?

def first[A](xs: List[A]): Option[A] = xs.headOption
println(first(List(1,2,3)))
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Сделать все ограничения типов максимально широкими, чтобы компилятор реже отклонял вызовы, а проверку перенести на время выполнения. Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. Использовать match type вместо небольшой предметной модели даже там, где ошибка может быть яснее проверена обычным `enum`. Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий. Передавайте `ClassTag`, `TypeTest` или явный декодер только там, где операция действительно зависит от типа во время выполнения.

Вопрос 4 из 20

В контракте темы «Параметры типов» локальный пример стал частью более крупной системы. Какая трактовка контракта остаётся полной?

Опираться на семантику «контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа», но отдельно проверять ограничение «стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации». Опираться на семантику «параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений», но отдельно проверять ограничение «одного примера достаточно, чтобы подтвердить законы абстракции и отсутствие побочных эффектов». Опираться на семантику «верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа», но отдельно проверять ограничение «метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек». Опираться на семантику «параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений», но отдельно проверять ограничение «пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип». Опираться на семантику «параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений», но отдельно проверять ограничение «стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации».

Вопрос 5 из 20

При проверке темы «Параметры типов» какой пункт следует добавить в критерии приёмки изменения?

Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. В проверке воспроизвести ситуацию: стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Передавайте `ClassTag`, `TypeTest` или явный декодер только там, где операция действительно зависит от типа во время выполнения. В проверке воспроизвести ситуацию: пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Передавайте `ClassTag`, `TypeTest` или явный декодер только там, где операция действительно зависит от типа во время выполнения. В проверке воспроизвести ситуацию: стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. В теме «Параметры типов» исправить один показанный вызов по рекомендации «Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий». Общий контракт и прежнюю границу отдельно не воспроизводить. Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений. Оставить тест без старой версии данных и неизвестных полей.

Вопрос 6 из 20

В теме «Ковариантность» код компилируется и запускается. Какое утверждение о его контракте остаётся верным?

sealed trait Animal
case class Cat(name: String) extends Animal
class Box[+A](val value: A)
val animals: Box[Animal] = Box(Cat("M"))
println(animals.value)

Контекстный параметр выбирается по имени значения; его точный тип и область импорта при поиске не учитываются. Ковариантность `Box[+A]` разрешает использовать `Box[Cat]` как `Box[Animal]`, если тип `A` только производится наружу. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа. Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений. Ковариантность разрешает принимать значения более общего типа, а контравариантность — возвращать более конкретный тип без ограничений.

Вопрос 7 из 20

Для темы «Ковариантность» какой пограничный случай относится к контракту, а не только к стилю записи?

// Дополнительный контекст: Обобщённую сигнатуру опубликовали в API, после чего появился ещё один допустимый экземпляр типа.
sealed trait Animal
case class Cat(name: String) extends Animal
class Box[+A](val value: A)
val animals: Box[Animal] = Box(Cat("M"))
println(animals.value)

Сложный тип может ухудшить только время компиляции; публичная совместимость и понятность ошибок от него не зависят. Потеря параметра типа на границе API не влияет на последующий поиск экземпляров и не меняет выбранное поведение. Пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек.

Вопрос 8 из 20

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

sealed trait Animal
case class Cat(name: String) extends Animal
class Box[+A](val value: A)
val animals: Box[Animal] = Box(Cat("M"))
println(animals.value)
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий. Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный. Преобразовывать значения opaque type через явное приведение на внешней границе, минуя проверяемый конструктор. Добавить второй равно приоритетный given и полагаться на порядок импортов как на механизм выбора поведения.

Вопрос 9 из 20

В контракте темы «Ковариантность» условия эксплуатации изменились, но синтаксис остался прежним. Что теперь важно удержать вместе?

Ковариантность `Box[+A]` разрешает использовать `Box[Cat]` как `Box[Animal]`, если тип `A` только производится наружу. Отдельная граница — успешная сборка гарантирует бинарную и исходную совместимость опубликованного API. Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений. Отдельная граница — метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа. Отдельная граница — стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Ковариантность `Box[+A]` разрешает использовать `Box[Cat]` как `Box[Animal]`, если тип `A` только производится наружу. Отдельная граница — метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек. Ковариантность `Box[+A]` разрешает использовать `Box[Cat]` как `Box[Animal]`, если тип `A` только производится наружу. Отдельная граница — пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип.

Вопрос 10 из 20

При проверке темы «Ковариантность» что поможет соседнему модулю не повторить ту же ошибку?

Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный. В проверке воспроизвести ситуацию: пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Ковариантность `Box[+A]` разрешает использовать `Box[Cat]` как `Box[Animal]`, если тип `A` только производится наружу. Проверить локальный успех, не моделируя частичный отказ внешнего сервиса. Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный. В проверке воспроизвести ситуацию: метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек. В теме «Ковариантность» исправить один показанный вызов по рекомендации «Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах». Общий контракт и прежнюю границу отдельно не воспроизводить. Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий. В проверке воспроизвести ситуацию: метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек.

Вопрос 11 из 20

В теме «Контравариантность» на ревью спорят о причине наблюдаемого результата. Какое объяснение корректно?

trait Show[-A]: def render(a: A): String
val anyShow: Show[Any] = (a: Any) => a.toString
val stringShow: Show[String] = anyShow
println(stringShow.render("ok"))

Ковариантность разрешает принимать значения более общего типа, а контравариантность — возвращать более конкретный тип без ограничений. Контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа. Параметры типа проверяются только после стирания на JVM, поэтому variance, bounds и поиск given не влияют на компиляцию вызова. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа. Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений.

Вопрос 12 из 20

Для темы «Контравариантность» типовую конструкцию перенесли в другой модуль, где набор импортов и область поиска `given` отличаются. Какой дефект остаётся возможным при корректном синтаксисе?

Потеря параметра типа на границе API не влияет на последующий поиск экземпляров и не меняет выбранное поведение. Стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек. Сложный тип может ухудшить только время компиляции; публичная совместимость и понятность ошибок от него не зависят. Пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип.

Вопрос 13 из 20

При исправлении темы «Контравариантность» на ревью уже воспроизвели проблему: Пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Какую правку стоит принять?

trait Show[-A]: def render(a: A): String
val anyShow: Show[Any] = (a: Any) => a.toString
val stringShow: Show[String] = anyShow
println(stringShow.render("ok"))
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Добавить второй равно приоритетный given и полагаться на порядок импортов как на механизм выбора поведения. Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный. Преобразовывать значения opaque type через явное приведение на внешней границе, минуя проверяемый конструктор. Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий.

Вопрос 14 из 20

В контракте темы «Контравариантность» какое решение не превращает частный успешный случай в общее обещание?

Оставить в контракте правило «параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений»; проверяемое ограничение — «стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации». Оставить в контракте правило «контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа»; проверяемое ограничение — «пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип». Оставить в контракте правило «контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа»; проверяемое ограничение — «метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек». Оставить в контракте правило «верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа»; проверяемое ограничение — «пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип». Оставить в контракте правило «контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа»; проверяемое ограничение — «одного успешного запуска достаточно, чтобы подтвердить контракт на всех входах».

Вопрос 15 из 20

При проверке темы «Контравариантность» какой контроль остаётся полезным после рефакторинга и переименования кода?

В теме «Контравариантность» исправить один показанный вызов по рекомендации «Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах». Общий контракт и прежнюю границу отдельно не воспроизводить. Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный. В проверке воспроизвести ситуацию: пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий. В проверке воспроизвести ситуацию: пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа. После правки ограничиться исходным примером без пограничного входа. Используйте контравариантность для потребителей, сравнителей, сериализаторов входа и обработчиков событий. В проверке воспроизвести ситуацию: метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек.

Вопрос 16 из 20

Какая характеристика конструкции «Границы типов» подтверждается показанным фрагментом?

def names[A <: Product](xs: List[A]) = xs.map(_.productPrefix)
println(names(List(Some(1), None)))

Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений. Расширение типа до супертипа всегда сохраняет самый специализированный given и доступные extension-методы. Ковариантность разрешает принимать значения более общего типа, а контравариантность — возвращать более конкретный тип без ограничений. Контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа.

Вопрос 17 из 20

Для темы «Границы типов» что здесь требует отдельного теста или компиляционного примера?

Одного обычного запуска недостаточно, поскольку неоднозначные given разрешаются выбором последнего импортированного экземпляра, поэтому порядок импортов задаёт стабильный приоритет. Одного обычного запуска недостаточно, поскольку сложный тип может ухудшить только время компиляции; публичная совместимость и понятность ошибок от него не зависят. Одного обычного запуска недостаточно, поскольку стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Одного обычного запуска недостаточно, поскольку пытаться возвращать `A` из контравариантного типа небезопасно: общий обработчик не обязан уметь создать конкретный подтип. Одного обычного запуска недостаточно, поскольку слишком узкая верхняя граница делает обобщение декоративным и блокирует полезные реализации; слишком широкая убирает доступные операции.

Вопрос 18 из 20

При исправлении темы «Границы типов» нужно устранить причину, а не замаскировать симптом. Какое изменение подходит лучше?

def names[A <: Product](xs: List[A]) = xs.map(_.productPrefix)
println(names(List(Some(1), None)))
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Использовать match type вместо небольшой предметной модели даже там, где ошибка может быть яснее проверена обычным `enum`. Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный. Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. Передавайте `ClassTag`, `TypeTest` или явный декодер только там, где операция действительно зависит от типа во время выполнения. Экспортировать зависимые от пути типы через каждый публичный метод: так владение станет заметнее всем клиентам библиотеки.

Вопрос 19 из 20

В контракте темы «Границы типов» после изменения окружения команда пересматривает контракт. Какой вариант корректен?

Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа; слишком узкая верхняя граница делает обобщение декоративным и блокирует полезные реализации; слишком широкая убирает доступные операции. Контравариантность `Consumer[-A]` позволяет обработчику общего типа служить там, где нужен обработчик более конкретного типа; слишком узкая верхняя граница делает обобщение декоративным и блокирует полезные реализации; слишком широкая убирает доступные операции. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа; сборка и один штатный пример полностью доказывают корректность для пограничных данных. Параметр типа связывает операции с типом данных и позволяет компилятору проверять согласованность без приведений; метод, принимающий `A`, нарушил бы безопасность: через ссылку `Box[Animal]` можно было бы положить собаку в коробку кошек. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа; стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации.

Вопрос 20 из 20

При проверке темы «Границы типов» какая проверка связывает принятую правку с реальной границей решения?

Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. В проверке воспроизвести ситуацию: стирание типов на JVM не позволяет в общем случае проверить `A` через обычный `isInstanceOf[A]` без дополнительной информации. Верхняя граница `A <: Base` требует подтип, нижняя `A >: Child` позволяет безопасно расширить результат до общего супертипа. Считать регрессию закрытой, если проект один раз собрался. В теме «Границы типов» исправить один показанный вызов по рекомендации «Для добавления используйте нижнюю границу и возвращайте расширенный новый контейнер, не изменяя исходный». Общий контракт и прежнюю границу отдельно не воспроизводить. Формулируйте минимальную границу, которая действительно нужна алгоритму, и проверяйте вывод типа на смешанных подтипах. В проверке воспроизвести ситуацию: слишком узкая верхняя граница делает обобщение декоративным и блокирует полезные реализации; слишком широкая убирает доступные операции. Передавайте `ClassTag`, `TypeTest` или явный декодер только там, где операция действительно зависит от типа во время выполнения. В проверке воспроизвести ситуацию: слишком узкая верхняя граница делает обобщение декоративным и блокирует полезные реализации; слишком широкая убирает доступные операции.