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

Вопрос 1 из 20

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

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

Вопрос 2 из 20

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

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

Вопрос 3 из 20

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

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

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

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

Вопрос 4 из 20

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

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

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

Вопрос 5 из 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 теряется после вынесения лямбды. Будет напечатано `[1], 2], 3]`: последняя лямбда передана за круглыми скобками, а `prefix` добавляется один раз. Возникнет ошибка из-за отсутствующего separator.

Вопрос 6 из 20

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

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

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

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

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

Вопрос 9 из 20

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

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

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

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

Вопрос 10 из 20

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

Параллельные вызовы лямбд с общим `var` создают гонку: захват не добавляет атомарности или синхронизации. Проверить, сохраняется ли контракт, когда возникнет `ConcurrentModificationException` при последовательных вызовах. Добавить регрессию на гипотезу: Будет выведен `[1, 1, 1]`, потому что каждая лямбда получает копию n. Зафиксировать сценарий, где ожидается: Код не компилируется: лямбда не может менять захваченную `var`. Проверить крайний ввод, при котором будет выведен `[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]" })

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

Вопрос 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 })

Контракт здесь понимают так: Возникнет ошибка, так как функцию нельзя вызвать больше одного раза. Причина результата в том, что будет выведено `5`, потому что результат первого вызова не передаётся во второй. Семантика фрагмента приводит к тому, что будет выведено `12`, поскольку лямбда умножается на число вызовов. Функциональный тип описывает типы параметров и результата; функция или лямбда является значением, которое можно передавать и возвращать. Поведение связывают с правилом: Код не компилируется без явного типа параметра `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 теряется после вынесения лямбды. Перенести проверку в вызывающий код, исходя из того, что будет напечатано `[1][2][3]`, потому что prefix применяется к каждому элементу. Вынести участок в отдельный метод, считая верным следующее: Код не компилируется: trailing lambda разрешена только без других аргументов. Использовать trailing lambda, когда она представляет исходное действие вызова; параметры конфигурации оставлять явно названными. Обернуть операцию проверкой и не менять основной контракт: Возникнет ошибка из-за отсутствующего separator.

Вопрос 16 из 20

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

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

Вопрос 17 из 20

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

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

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

Вопрос 18 из 20

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

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

Вопрос 19 из 20

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

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

Вопрос 20 из 20

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

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

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