Лямбды и функции высшего порядка — бесплатный тест онлайн

Вопрос 1 из 20

Какой редкий случай способен сломать наивную трактовку «Функция как значение»?

Зафиксировать сценарий, где ожидается: Будет выведено `5`, потому что результат первого вызова не передаётся во второй. Отдельно воспроизвести случай, в котором код не компилируется без явного типа параметра `it`. Воспроизвести редкий сценарий, где возникнет ошибка, так как функцию нельзя вызвать больше одного раза. Проверить, сохраняется ли контракт, когда будет выведено `12`, поскольку лямбда умножается на число вызовов. Лямбда с receiver `(T.() -> R)` и обычная `(T) -> R` похожи по возможностям, но дают разную область имён и читаемость DSL.

Вопрос 2 из 20

Для «Лямбда после круглых скобок» предлагают правку: Использовать trailing lambda, когда она представляет исходное действие вызова; параметры конфигурации оставлять явно названными. Какой компромисс нельзя пропустить?

Главный риск формулируют так: Будет напечатано `1], 2], 3]`, поскольку prefix теряется после вынесения лямбды. Граница полезности решения описывается условием: Код не компилируется: trailing lambda разрешена только без других аргументов. Главная цена решения — необходимость учитывать, что будет напечатано `[1][2][3]`, потому что prefix применяется к каждому элементу. Цена упрощения проявится, если возникнет ошибка из-за отсутствующего separator. Синтаксис делает управляющие конструкции похожими на язык, но может скрывать обычный вызов функции и усложнять поиск параметров.

Вопрос 3 из 20

Какой результат даст пример «Лямбда с receiver» без изменения окружения?

// Проследите фактическое выполнение без изменения кода.
fun build(block: StringBuilder.() -> Unit): String =
    StringBuilder().apply(block).toString()

fun main() = println(build { append("K"); append(length) })

Будет выведено `K2`, поскольку `append(length)` сначала увеличивает длину. Будет `K1`: receiver — `StringBuilder`, чья длина после первой вставки равна единице. Код не компилируется: методы receiver нужно вызывать через `this.`. Будет выведено `K0`, потому что `length` вычисляется до выполнения блока. Возникнет рекурсия: `append` относится к функции build.

Вопрос 4 из 20

Какой принцип лежит в основе поведения «Общее состояние замыканий»?

// На ревью требуется объяснить причину поведения.
fun counters(): List<() -> Int> {
    var n = 0
    return List(3) { { ++n } }
}
fun main() = println(counters().map { it() })

Замыкание захватывает доступное окружение; для изменяемого значения несколько лямбд могут разделять одно состояние. Из правил языка или API следует, что будет выведен `[3, 3, 3]`, так как инкремент выполняется при создании списка. Механика примера описывается утверждением: Код не компилируется: лямбда не может менять захваченную `var`. Причина результата в том, что возникнет `ConcurrentModificationException` при последовательных вызовах. Такой результат объясняют тем, что будет выведен `[1, 1, 1]`, потому что каждая лямбда получает копию n.

Вопрос 5 из 20

Какая строка будет напечатана?

// Проследите фактическое выполнение без изменения кода.
fun collect(prefix: String, block: (Int) -> String): String =
    (1..3).joinToString(prefix = prefix, transform = block)

fun main() = println(collect("[") { n -> "$n]" })

Возникнет ошибка из-за отсутствующего separator. Будет напечатано `1], 2], 3]`, поскольку prefix теряется после вынесения лямбды. Будет напечатано `[1], 2], 3]`: последняя лямбда передана за круглыми скобками, а `prefix` добавляется один раз. Код не компилируется: trailing lambda разрешена только без других аргументов. Будет напечатано `[1][2][3]`, потому что prefix применяется к каждому элементу.

Вопрос 6 из 20

На какой контракт языка или библиотеки опирается «Лямбда с receiver»?

// На ревью требуется объяснить причину поведения.
fun build(block: StringBuilder.() -> Unit): String =
    StringBuilder().apply(block).toString()

fun main() = println(build { append("K"); append(length) })

Функциональный тип с receiver вводит неявный `this`, но не меняет фактический объект и правила разрешения имён. Поведение связывают с правилом: Будет выведено `K0`, потому что `length` вычисляется до выполнения блока. Контракт здесь понимают так: Код не компилируется: методы receiver нужно вызывать через `this.`. Объяснение опирается на утверждение: Будет выведено `K2`, поскольку `append(length)` сначала увеличивает длину. Наблюдаемое поведение выводят из того, что возникнет рекурсия: `append` относится к функции build.

Вопрос 7 из 20

Что стоит исправить в «Общее состояние замыканий» перед слиянием?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun counters(): List<() -> Int> {
    var n = 0
    return List(3) { { ++n } }
}
fun main() = println(counters().map { it() })

Ограничиться поясняющим комментарием о том, что будет выведен `[3, 3, 3]`, так как инкремент выполняется при создании списка. Сохранить API и считать достаточным условие: Будет выведен `[1, 1, 1]`, потому что каждая лямбда получает копию n. Перенести проверку в вызывающий код, исходя из того, что возникнет `ConcurrentModificationException` при последовательных вызовах. Спрятать участок за вспомогательной функцией, сохранив предположение: Код не компилируется: лямбда не может менять захваченную `var`. Сделать состояние явным объектом или создать отдельную локальную переменную на итерацию, если счётчики должны быть независимыми.

Вопрос 8 из 20

Какой побочный эффект существеннее остальных после правки «Функция как значение»: Называть функциональный параметр по роли и при сложном контракте заменить голую сигнатуру на `fun interface`?

Новый риск связан с тем, что будет выведено `5`, потому что результат первого вызова не передаётся во второй. Решение оправдано лишь при условии: Будет выведено `12`, поскольку лямбда умножается на число вызовов. Обратная сторона изменения состоит в том, что код не компилируется без явного типа параметра `it`. Сопровождение усложнится, если окажется, что возникнет ошибка, так как функцию нельзя вызвать больше одного раза. Функциональные параметры уменьшают число классов-стратегий, но длинные сигнатуры хуже документируют смысл и ошибки.

Вопрос 9 из 20

Какую правку выбрать, чтобы сохранить назначение «Лямбда с receiver» и убрать хрупкость?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun build(block: StringBuilder.() -> Unit): String =
    StringBuilder().apply(block).toString()

fun main() = println(build { append("K"); append(length) })

Оставить структуру прежней, документировав утверждение: Будет выведено `K0`, потому что `length` вычисляется до выполнения блока. Ограничивать receiver узким builder-интерфейсом, чтобы DSL не открывал лишние изменяющие операции. Обернуть операцию проверкой и не менять основной контракт: Код не компилируется: методы receiver нужно вызывать через `this.`. Передать ответственность владельцу вызова, предполагая, что будет выведено `K2`, поскольку `append(length)` сначала увеличивает длину. Зафиксировать текущее поведение регрессионным тестом: Возникнет рекурсия: `append` относится к функции build.

Вопрос 10 из 20

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

Проверить, сохраняется ли контракт, когда возникнет `ConcurrentModificationException` при последовательных вызовах. Параллельные вызовы лямбд с общим `var` создают гонку: захват не добавляет атомарности или синхронизации. Зафиксировать сценарий, где ожидается: Код не компилируется: лямбда не может менять захваченную `var`. Добавить регрессию на гипотезу: Будет выведен `[1, 1, 1]`, потому что каждая лямбда получает копию n. Проверить крайний ввод, при котором будет выведен `[3, 3, 3]`, так как инкремент выполняется при создании списка.

Вопрос 11 из 20

Что появится в выводе примера «Функция как значение»?

// Проследите фактическое выполнение без изменения кода.
fun applyTwice(x: Int, f: (Int) -> Int) = f(f(x))
fun main() = println(applyTwice(3) { it + 2 })

Возникнет ошибка, так как функцию нельзя вызвать больше одного раза. Будет выведено `5`, потому что результат первого вызова не передаётся во второй. Код не компилируется без явного типа параметра `it`. Будет выведено `7`: лямбда прибавляет два при каждом из двух вызовов. Будет выведено `12`, поскольку лямбда умножается на число вызовов.

Вопрос 12 из 20

Какое правило определяет поведение фрагмента «Лямбда после круглых скобок»?

// На ревью требуется объяснить причину поведения.
fun collect(prefix: String, block: (Int) -> String): String =
    (1..3).joinToString(prefix = prefix, transform = block)

fun main() = println(collect("[") { n -> "$n]" })

Если последний параметр функции является функциональным, соответствующую лямбду можно вынести за круглые скобки. Причину поведения формулируют так: Возникнет ошибка из-за отсутствующего separator. Поведение связывают с правилом: Будет напечатано `1], 2], 3]`, поскольку prefix теряется после вынесения лямбды. Семантика фрагмента приводит к тому, что код не компилируется: trailing lambda разрешена только без других аргументов. Причина результата в том, что будет напечатано `[1][2][3]`, потому что prefix применяется к каждому элементу.

Вопрос 13 из 20

Решение для «Общее состояние замыканий»: Сделать состояние явным объектом или создать отдельную локальную переменную на итерацию, если счётчики должны быть независимыми. Что в нём остаётся не бесплатным?

Сопровождение усложнится, если окажется, что код не компилируется: лямбда не может менять захваченную `var`. Замыкание удобно для небольшого состояния, но скрытое совместное владение ухудшает тестируемость и конкурентную безопасность. После правки останется ограничение: Возникнет `ConcurrentModificationException` при последовательных вызовах. Решение оправдано лишь при условии: Будет выведен `[1, 1, 1]`, потому что каждая лямбда получает копию n. Обратная сторона изменения состоит в том, что будет выведен `[3, 3, 3]`, так как инкремент выполняется при создании списка.

Вопрос 14 из 20

Что в семантике Kotlin или используемого API объясняет «Функция как значение»?

// На ревью требуется объяснить причину поведения.
fun applyTwice(x: Int, f: (Int) -> Int) = f(f(x))
fun main() = println(applyTwice(3) { it + 2 })

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

Вопрос 15 из 20

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

// Сохраните назначение фрагмента, но укрепите его контракт.
fun collect(prefix: String, block: (Int) -> String): String =
    (1..3).joinToString(prefix = prefix, transform = block)

fun main() = println(collect("[") { n -> "$n]" })

Перенести проверку в вызывающий код, исходя из того, что будет напечатано `[1][2][3]`, потому что prefix применяется к каждому элементу. Вынести участок в отдельный метод, считая верным следующее: Код не компилируется: trailing lambda разрешена только без других аргументов. Оставить структуру прежней, документировав утверждение: Будет напечатано `1], 2], 3]`, поскольку prefix теряется после вынесения лямбды. Использовать trailing lambda, когда она представляет исходное действие вызова; параметры конфигурации оставлять явно названными. Обернуть операцию проверкой и не менять основной контракт: Возникнет ошибка из-за отсутствующего separator.

Вопрос 16 из 20

Что проверить отдельно, чтобы не принять «Лямбда с receiver» за универсальное правило?

Вложенные receiver-лямбды могут иметь одинаковые имена членов; тогда нужны метки `this@...` или DSL-маркеры. Зафиксировать сценарий, где ожидается: Код не компилируется: методы receiver нужно вызывать через `this.`. Проверить крайний ввод, при котором будет выведено `K0`, потому что `length` вычисляется до выполнения блока. Добавить граничный тест на утверждение: Будет выведено `K2`, поскольку `append(length)` сначала увеличивает длину. Отдельно воспроизвести случай, в котором возникнет рекурсия: `append` относится к функции build.

Вопрос 17 из 20

Как укрепить «Функция как значение», не переписывая соседние модули?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun applyTwice(x: Int, f: (Int) -> Int) = f(f(x))
fun main() = println(applyTwice(3) { it + 2 })

Оставить структуру прежней, документировав утверждение: Возникнет ошибка, так как функцию нельзя вызвать больше одного раза. Оставить реализацию без изменений и закрепить тестом предположение: Код не компилируется без явного типа параметра `it`. Добавить защитную проверку перед фрагментом, поскольку будет выведено `5`, потому что результат первого вызова не передаётся во второй. Перенести проверку в вызывающий код, исходя из того, что будет выведено `12`, поскольку лямбда умножается на число вызовов. Называть функциональный параметр по роли и при сложном контракте заменить голую сигнатуру на `fun interface`.

Вопрос 18 из 20

Какой сценарий выявит скрытое ограничение «Лямбда после круглых скобок»?

Добавить тест на состояние, при котором будет напечатано `1], 2], 3]`, поскольку prefix теряется после вынесения лямбды. Проверить границу полезности утверждения: Код не компилируется: trailing lambda разрешена только без других аргументов. Проверить соседний случай: Возникнет ошибка из-за отсутствующего separator. Воспроизвести редкий сценарий, где будет напечатано `[1][2][3]`, потому что prefix применяется к каждому элементу. При нескольких функциональных параметрах за скобки выносится только последний, а остальные остаются внутри вызова.

Вопрос 19 из 20

В «Лямбда с receiver» выбрали решение: Ограничивать receiver узким builder-интерфейсом, чтобы DSL не открывал лишние изменяющие операции. Какова его реальная цена?

Граница полезности решения описывается условием: Будет выведено `K2`, поскольку `append(length)` сначала увеличивает длину. Главный риск формулируют так: Возникнет рекурсия: `append` относится к функции build. Главная цена решения — необходимость учитывать, что код не компилируется: методы receiver нужно вызывать через `this.`. Receiver делает конфигурацию выразительной, но неявный контекст повышает цену чтения при глубокой вложенности. После правки останется ограничение: Будет выведено `K0`, потому что `length` вычисляется до выполнения блока.

Вопрос 20 из 20

Что выведет фрагмент «Общее состояние замыканий»?

// Проследите фактическое выполнение без изменения кода.
fun counters(): List<() -> Int> {
    var n = 0
    return List(3) { { ++n } }
}
fun main() = println(counters().map { it() })

Будет выведен `[1, 2, 3]`: все три лямбды захватывают одну изменяемую переменную `n`. Будет выведен `[1, 1, 1]`, потому что каждая лямбда получает копию n. Возникнет `ConcurrentModificationException` при последовательных вызовах. Код не компилируется: лямбда не может менять захваченную `var`. Будет выведен `[3, 3, 3]`, так как инкремент выполняется при создании списка.