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

Вопрос 1 из 25

Какой из пяти выводов подтверждается построчной трассировкой? Не упускайте из виду следующее: вывод параметра типа и смысл повторного использования T.

func first<T>(_ values: [T]) -> T? { values.first }
print(first(["a", "b"]) as Any)

Компилятор выводит T как String, функция возвращает Optional с «b». Компилятор выводит T как String, функция не возвращает Optional с «a». Последняя строка ведёт себя именно так, потому что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Компилятор выводит T как String, функция возвращает Result с «a». Компилятор выводит T как String, функция возвращает Optional с «a».

Вопрос 2 из 25

Определите не предполагаемое, а фактическое поведение примера «Ограничения типов». Проверяется связь доступных операций с требованиями протокола.

func contains<T: Equatable>(_ values: [T], _ value: T) -> Bool {
    values.contains(value)
}
print(contains([1, 2, 3], 2))

Ограничение Hashable даёт доступ к сравнению, и функция печатает true. Наблюдаемый результат определяется тем, что ошибка вывода типа обычно исправляется стиранием значения в `Any`. Ограничение Equatable даёт доступ к сравнению, и функция печатает true. Операция с `contains` корректна, поскольку `some P` выбирает конкретный тип вызывающей стороной. Ограничение Equatable даёт доступ к сравнутринию, и функция печатает true.

Вопрос 3 из 25

Какой из пяти выводов подтверждается построчной трассировкой? Важно учесть: выражение отношений между несколькими типами.

func equalStarts<C1: Collection, C2: Collection>(_ a: C1, _ b: C2) -> Bool
where C1.Element == C2.Element, C1.Element: Equatable {
    a.first == b.first
}
print(equalStarts([1, 2], [1, 9]))

Операция с `equalStarts` корректна, поскольку условие `where` проверяется во время выполнения, а не компилятором. where связывает типы элементов двух коллекций и требует Equatable; результат true. where связывает типы элементов двух коллекций и не требует Equatable; результат true. Для этого примера достаточно учесть, что ограничение `Equatable` достаточно для использования оператора `<`. where связывает типы элементов двух коллекций и требует Hashable; результат true.

Вопрос 4 из 25

Проследите типы, изменения состояния и порядок вызовов. Какое описание результата совпадает с кодом? Здесь оценивается единый скрытый тип и различие some/any.

protocol Shape { func area() -> Double }
struct Square: Shape { let side: Double; func area() -> Double { side * side } }
func makeShape() -> some Shape { Square(side: 3) }
print(makeShape().area())

Для этого примера достаточно учесть, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. some скрывает конкретный тип от вызывающего кода, но функция стабильно возвращает один и тот же конкретный тип Square. Последняя строка ведёт себя именно так, потому что ошибка вывода типа обычно исправляется стиранием значения в `Any`. any скрывает конкретный тип от вызывающего кода, но функция стабильно возвращает один и тот же конкретный тип Square. some не скрывает конкретный тип от вызывающего кода, но функция стабильно возвращает один и тот же конкретный тип Square.

Вопрос 5 из 25

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Здесь оценивается чтение сообщений вывода типов и построение минимального воспроизводимого примера.

func identity<T>(_ value: T) -> T { value }
let x: Int = identity(3)
let y: String = identity("3")
print(x, y)

Операция с `identity` корректна, поскольку ошибка вывода типа обычно исправляется стиранием значения в `Any`. Два вызова специализируются независимо: печатаются число 4 и строка «3». Наблюдаемый результат определяется тем, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Два вызова специализируются независимо: печатаются число 3 и строка «3». Два вызова специализируются независимо: печатаются число 3 и строка «4».

Вопрос 6 из 25

Что в этом фрагменте нужно объяснить первым, чтобы дальнейшая правка не оказалась случайной? Здесь оценивается вывод параметра типа и смысл повторного использования T.

func same<T>(_ a: T, _ b: T) -> Bool { true }
let integer: Int = 1
let fraction: Double = 2.0
let ok = same(integer, fraction)

Вызов не компилируется: оба аргумента не должны иметь один и тот же T, а Int и Double не выводятся как единый тип. Причина сбоя в том, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Первой нарушенной гарантией здесь является предположение, что ограничение `Equatable` достаточно для использования оператора `<`. Вызов не компилируется: оба аргумента должны иметь один и тот же T, а Int и Double не выводятся как единый тип. Вызов компилируется: оба аргумента должны иметь один и тот же T, а Int и Double не выводятся как единый тип.

Вопрос 7 из 25

Какой диагноз согласуется и с исходным кодом, и с правилами Swift? Сосредоточьтесь на следующем: связь доступных операций с требованиями протокола.

func maxValue<T>(_ a: T, _ b: T) -> T {
    a > b ? a : b
}

Код проходит проверку типов: для оператора > параметр T должен быть как минимум Comparable. Наблюдаемый симптом объясняется тем, что `some P` выбирает конкретный тип вызывающей стороной. Код не компилируется: для оператора > параметр T должен быть как минимум Comparable. Код компилируется: для оператора > параметр T должен быть как минимум Comparable. Код не компилируется: для оператора > параметр T должен быть как минимум Equatable.

Вопрос 8 из 25

Что в этом фрагменте нужно объяснить первым, чтобы дальнейшая правка не оказалась случайной? Здесь оценивается выражение отношений между несколькими типами.

func merge<C1: Collection, C2: Collection>(_ a: C1, _ b: C2) -> [C1.Element]
where C1.Element: Hashable {
    Array(a) + Array(b)
}

Код компилируется: не доказано, что C2.Element совпадает с C1.Element. Причина сбоя в том, что ограничение `Equatable` достаточно для использования оператора `<`. Наблюдаемый симптом объясняется тем, что `some P` выбирает конкретный тип вызывающей стороной. Первой нарушенной гарантией здесь является предположение, что условие `where` проверяется во время выполнения, а не компилятором. Код не компилируется: не доказано, что C2.Element совпадает с C1.Element.

Вопрос 9 из 25

Почему этот код не выполняет заявленный контракт? Проверяется единый скрытый тип и различие some/any.

protocol P4 {}
struct A4: P4 {}
struct B4: P4 {}
func make(_ flag: Bool) -> some P4 {
    flag ? A4() : B4()
}

Код компилируется: все пути функции с opaque return type должны возвращать один конкретный скрытый тип. Код не компилируется: все пути функции с opaque return type должны возвращать один конкретный скрытый тип. Причина сбоя в том, что `some P` выбирает конкретный тип вызывающей стороной. Первой нарушенной гарантией здесь является предположение, что ошибка вывода типа обычно исправляется стиранием значения в `Any`. Код проходит проверку типов: все пути функции с opaque return type должны возвращать один конкретный скрытый тип.

Вопрос 10 из 25

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Сосредоточьтесь на следующем: чтение сообщений вывода типов и построение минимального воспроизводимого примера.

func load<T>() -> T { fatalError() }
let value = load()

Проблема возникает из-за правила: `some P` выбирает конкретный тип вызывающей стороной. Компилятор может вывести T из вызова без контекста ожидаемого типа. Компилятор не может вывести T из вызова без контекста ожидаемого типа. Отчёт об ошибке должен указывать, что условие `where` проверяется во время выполнения, а не компилятором. Наблюдаемый симптом объясняется тем, что ограничение `Equatable` достаточно для использования оператора `<`.

Вопрос 11 из 25

Какая правка решает проблему на том уровне, где она возникла? Проверяется вывод параметра типа и смысл повторного использования T.

func same<T>(_ a: T, _ b: T) -> Bool { true }
let integer: Int = 1
let fraction: Double = 2.0
let ok = same(integer, fraction)

Либо явно привести значения к общему типу, либо ввести два параметра типа, если равенство типов является частью контракта. Сигнатуру можно не менять, если считать, что ограничение `Equatable` достаточно для использования оператора `<`. Либо явно привести значения к общему типу, либо ввести два параметра типа, если равенство типов не является частью контракта. Правка сводится к локальному обходу: generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Достаточно изменить работу с `same`, исходя из того, что ошибка вывода типа обычно исправляется стиранием значения в `Any`.

Вопрос 12 из 25

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

func maxValue<T>(_ a: T, _ b: T) -> T {
    a > b ? a : b
}

Добавить T: Comparable, расширяя требование до более тяжёлого протокола без необходимости. Так сохраняются существующие вызовы maxValue и не требуется менять публичную форму «Ограничения типов». Добавить T: Equatable, не расширяя требование до более тяжёлого протокола без необходимости. Нужно адаптировать только вызов `maxValue`, поскольку generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Добавить T: Comparable, не расширяя требование до более тяжёлого протокола без необходимости. Сигнатуру можно не менять, если считать, что ошибка вывода типа обычно исправляется стиранием значения в `Any`.

Вопрос 13 из 25

Какой вариант ремонта вы бы приняли после содержательной проверки кода? Важно учесть: выражение отношений между несколькими типами.

func merge<C1: Collection, C2: Collection>(_ a: C1, _ b: C2) -> [C1.Element]
where C1.Element: Hashable {
    Array(a) + Array(b)
}

Добавить условие C1.Element == C2.Element либо изменить возвращаемый тип и алгоритм так, чтобы разные элементы были допустимы. Исправление — оставить контракт прежним и учитывать, что ошибка вывода типа обычно исправляется стиранием значения в `Any`. Правка сводится к локальному обходу: ограничение `Equatable` достаточно для использования оператора `<`. Сигнатуру можно не менять, если считать, что условие `where` проверяется во время выполнения, а не компилятором. Достаточно изменить работу с `merge`, исходя из того, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры.

Вопрос 14 из 25

Какое решение одновременно исправляет код и оставляет понятную границу для дальнейших изменений? Не упускайте из виду следующее: единый скрытый тип и различие some/any.

protocol P4 {}
struct A4: P4 {}
struct B4: P4 {}
func make(_ flag: Bool) -> some P4 {
    flag ? A4() : B4()
}

Вернуть один конкретный тип, применить обёртку-структуру или использовать any P4, если нужна разнородность во время выполнения. Нужно адаптировать только вызов `A4`, поскольку `some P` выбирает конкретный тип вызывающей стороной. Сигнатуру можно не менять, если считать, что условие `where` проверяется во время выполнения, а не компилятором. Вернуть один конкретный тип, применить обёртку-структуру или использовать some P4, если нужна разнородность во время выполнения. Правка сводится к локальному обходу: ограничение `Equatable` достаточно для использования оператора `<`.

Вопрос 15 из 25

Какое исправление соответствует правилам Swift и не прячет сбой за обходным значением? Проверяется чтение сообщений вывода типов и построение минимального воспроизводимого примера.

func load<T>() -> T { fatalError() }
let value = load()

В тесте указать ожидаемый тип явно либо изменить API так, чтобы тип выводился из аргумента, а не только из результата. Правка сводится к локальному обходу: `some P` выбирает конкретный тип вызывающей стороной. Исправление — оставить контракт прежним и учитывать, что ограничение `Equatable` достаточно для использования оператора `<`. Достаточно изменить работу с `load`, исходя из того, что условие `where` проверяется во время выполнения, а не компилятором. В тесте указать ожидаемый тип явно либо изменить API так,только из результата, а не чтобы тип выводился из аргумента.

Вопрос 16 из 25

Какой пограничный случай способен изменить вывод, хотя синтаксис останется почти тем же? Проверяется вывод параметра типа и смысл повторного использования T.

Обобщение сохраняет статический тип и обычно не требует упаковки значения в Any. Пограничный случай связан с тем, что `some P` выбирает конкретный тип вызывающей стороной. Обобщение не сохраняет статический тип и обычно не требует упаковки значения в Any. Обобщение сохраняет статический тип и обычно требует упаковки значения в Any. Граница применимости проходит там, где условие `where` проверяется во время выполнения, а не компилятором.

Вопрос 17 из 25

Какую предпосылку стоит явно записать в документации и тестах? Важно учесть: связь доступных операций с требованиями протокола.

Ограничение может стоять у параметра типа или в where; это разные формы одного контракта, а не разные механизмы выполнения. Контрпример появляется, когда условие `where` проверяется во время выполнения, а не компилятором. Ограничение не может стоять у параметра типа или в where; это разные формы одного контракта, а не разные механизмы выполнения. Правило меняется только в ситуации, где generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Ограничение определяется предположением, что ограничение `Equatable` достаточно для использования оператора `<`.

Вопрос 18 из 25

Какой пограничный случай способен изменить вывод, хотя синтаксис останется почти тем же? Проверяется выражение отношений между несколькими типами.

Ограничение определяется предположением, что ограничение `Equatable` достаточно для использования оператора `<`. where особенно полезен для отношений между associated types, которые нельзя выразить одной короткой записью после имени типа. Правило меняется только в ситуации, где generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Пограничный случай связан с тем, что ошибка вывода типа обычно исправляется стиранием значения в `Any`. where особенно полезен для отношений между associated types, которые можно выразить одной короткой записью после имени типа.

Вопрос 19 из 25

Какой отрицательный сценарий лучше всего проверяет предел применимости этого механизма? Не упускайте из виду следующее: единый скрытый тип и различие some/any.

some сохраняет статическую специализацию и идентичность скрытого типа, а any хранит значение произвольного соответствующего типа. any сохраняет статическую специализацию и идентичность скрытого типа, а any хранит значение произвольного соответствующего типа. some не сохраняет статическую специализацию и идентичность скрытого типа, а any хранит значение произвольного соответствующего типа. Граница применимости проходит там, где `some P` выбирает конкретный тип вызывающей стороной. some сохраняет статическую специализацию и идентичность скрытого типа, а some хранит значение произвольного соответствующего типа.

Вопрос 20 из 25

Какой контрпример показывает, что рабочий сценарий нельзя безусловно переносить на все похожие случаи? Важно учесть: чтение сообщений вывода типов и построение минимального воспроизводимого примера.

Правило меняется только в ситуации, где ошибка вывода типа обычно исправляется стиранием значения в `Any`. Пограничный случай связан с тем, что `some P` выбирает конкретный тип вызывающей стороной. Ошибка «generic parameter could not be inferred» часто не означает нехватку контекста, а не необходимость добавить случайное as. Ошибка «generic parameter could not be inferred» часто означает нехватку контекста, а не необходимость добавить случайное as. Ошибка «nil» часто означает нехватку контекста, а не необходимость добавить случайное as.

Вопрос 21 из 25

Как организовать этот механизм, чтобы владение и отказ оставались понятными после расширения проекта? Здесь оценивается вывод параметра типа и смысл повторного использования T.

Параметр типа стоит вводить только для реальной связи между входами и выходом; неиспользуемая общность делает API сложнее. Для устойчивого решения достаточно принять, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Архитектуру стоит строить из предположения, что ошибка вывода типа обычно исправляется стиранием значения в `Any`. В API и тестах следует исходить из правила: ограничение `Equatable` достаточно для использования оператора `<`. При расширении системы нужно опираться на то, что `some P` выбирает конкретный тип вызывающей стороной.

Вопрос 22 из 25

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Здесь оценивается связь доступных операций с требованиями протокола.

В API и тестах следует исходить из правила: ошибка вывода типа обычно исправляется стиранием значения в `Any`. При расширении системы нужно опираться на то, что ограничение `Equatable` достаточно для использования оператора `<`. Минимальное ограничение делает функцию применимой к большему числу типов и яснее показывает, какие операции ей действительно нужны. Для устойчивого решения достаточно принять, что `some P` выбирает конкретный тип вызывающей стороной. Архитектуру стоит строить из предположения, что условие `where` проверяется во время выполнения, а не компилятором.

Вопрос 23 из 25

Какое замечание на проверке кода поможет предотвратить повторение такого дефекта? Не упускайте из виду следующее: выражение отношений между несколькими типами.

Главным проектным принципом здесь является утверждение, что ограничение `Equatable` достаточно для использования оператора `<`. Сложное where стоит читать как набор доказательств, необходимых телу функции; лишнее требование ограничивает повторное использование. При расширении системы нужно опираться на то, что условие `where` проверяется во время выполнения, а не компилятором. Архитектуру стоит строить из предположения, что `some P` выбирает конкретный тип вызывающей стороной. Для устойчивого решения достаточно принять, что ошибка вывода типа обычно исправляется стиранием значения в `Any`.

Вопрос 24 из 25

Что должно определять архитектуру этого участка, когда появятся новые входы и владельцы? Важно учесть: единый скрытый тип и различие some/any.

Opaque type хорош, когда реализацию нужно скрыть без потери статических гарантий; он является универсальной заменой existential. Opaque type хорош, когда реализацию нужно скрыть без потери статических гарантий; он не является универсальной заменой existential. Архитектуру стоит строить из предположения, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры. Для устойчивого решения достаточно принять, что ограничение `Equatable` достаточно для использования оператора `<`. В API и тестах следует исходить из правила: условие `where` проверяется во время выполнения, а не компилятором.

Вопрос 25 из 25

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Важно учесть: чтение сообщений вывода типов и построение минимального воспроизводимого примера.

Диагностику обобщённого кода лучше начинать с минимальной сигнатуры и проверки каждого ограничения отдельно. В API и тестах следует исходить из правила: ограничение `Equatable` достаточно для использования оператора `<`. Архитектуру стоит строить из предположения, что ошибка вывода типа обычно исправляется стиранием значения в `Any`. При расширении системы нужно опираться на то, что `some P` выбирает конкретный тип вызывающей стороной. Для устойчивого решения достаточно принять, что generic-функция принимает разные типы в двух параметрах `T` без дополнительной сигнатуры.