Result builders — бесплатный тест онлайн

Вопрос 1 из 25

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

@resultBuilder enum ListBuilder20 {
    static func buildBlock(_ parts: [Int]...) -> [Int] { parts.flatMap { $0 } }
    static func buildExpression(_ value: Int) -> [Int] { [value] }
}
@ListBuilder20 func numbers20() -> [Int] { 1; 2; 3 }
print(numbers20())

Фрагмент не требует отдельного условия: снимок итогового значения полностью заменяет тест отдельных преобразований. buildExpression превращает каждое Int в массив, buildBlock объединяет части; результат [1, 3, 3]. buildExpression превращает каждое Int в массив, buildBlock объединяет части; результат [1, 2, 3]. buildExpression превращает каждое Int в массив, buildBlock объединяет части; результат [2, 2, 3]. buildExpression превращает каждое Int в массив, buildBlock объединяет части; результат [1, 2, 4].

Вопрос 2 из 25

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

@resultBuilder enum TextBuilder20 {
    static func buildBlock(_ parts: String...) -> String { parts.joined() }
    static func buildEither(first: String) -> String { first }
    static func buildEither(second: String) -> String { second }
}

Пара buildEither не позволяет построителю представить ветви if/else одного компонентного типа. Операция с `TextBuilder20` корректна, поскольку порядок вызовов методов построителя не зависит от структуры исходного блока. Последняя строка ведёт себя именно так, потому что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Для этого примера достаточно учесть, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Пара buildEither позволяет построителю представить ветви if/else одного компонентного типа.

Вопрос 3 из 25

Где окажется состояние программы после выполнения всех показанных операций? Здесь оценивается отделение описания от исполнения.

struct Field20 { let name: String }
@resultBuilder enum FormBuilder20 {
    static func buildBlock(_ fields: Field20...) -> [Field20] { fields }
}
@FormBuilder20 func form20() -> [Field20] { Field20(name: "email"); Field20(name: "age") }

Операция с `Field20` корректна, поскольку ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Построитель создаёт декларативный список из двух полей без скрытого изменения общего состояния. Наблюдаемый результат определяется тем, что порядок вызовов методов построителя не зависит от структуры исходного блока. Построитель не создаёт декларативный список из двух полей без скрытого изменения общего состояния. Фрагмент не требует отдельного условия: снимок итогового значения полностью заменяет тест отдельных преобразований.

Вопрос 4 из 25

В этом примере важна одна точная деталь механизма «Диагностика ошибок». Что действительно произойдёт? Здесь оценивается методика разбора ошибок построителя результата.

@resultBuilder
enum IntBuilder20 {
    static func buildBlock(_ values: Int...) -> [Int] { values }
    static func buildExpression(_ value: Int) -> Int { value }
    static func buildExpression(_ value: String) -> Int { Int(value) ?? 0 }
}

@IntBuilder20
func values20() -> [Int] {
    1
    "2"
}

print(values20())

Перегрузки buildExpression принимают и Int, и String; строка «3» преобразуется в число, поэтому функция возвращает [1, 2]. Для этого примера достаточно учесть, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Перегрузки buildExpression принимают и Int, и String; строка «2» преобразуется в число, поэтому функция возвращает [2, 2]. Перегрузки buildExpression принимают и Int, и String; строка «2» преобразуется в число, поэтому функция возвращает [1, 2]. Перегрузки buildExpression принимают и Int, и String; строка «2» преобразуется в число, поэтому функция возвращает [1, 3].

Вопрос 5 из 25

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

struct Field20 { let name: String }

@resultBuilder
enum FormBuilder20 {
    static func buildBlock(_ fields: Field20...) -> [Field20] { fields }
}

@FormBuilder20
func empty20() -> [Field20] { }

Пустое тело поддерживается, потому что вариативный buildBlock не может быть вызван без аргументов и вернуть пустой массив. Пустое тело поддерживается, потому что вариативный buildBlock может быть вызван без аргументов и вернуть пустой массив. Последняя строка ведёт себя именно так, потому что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Наблюдаемый результат определяется тем, что снимок итогового значения полностью заменяет тест отдельных преобразований. Фрагмент не требует отдельного условия: построитель результата исполняет DSL как интерпретатор во время выполнения.

Вопрос 6 из 25

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

@resultBuilder enum B20 {
    static func buildBlock(_ values: Int...) -> [Int] { values }
}
@B20 func f20() -> [Int] { "x" }

Код компилируется: построитель не умеет преобразовать выражение String в ожидаемый компонент Int. Проблема возникает из-за правила: порядок вызовов методов построителя не зависит от структуры исходного блока. Код компилируется и проходит проверку типов: построитель не умеет преобразовать выражение String в ожидаемый компонент Int. Код не компилируется: построитель не умеет преобразовать выражение String в ожидаемый компонент Int. Отчёт об ошибке должен указывать, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение.

Вопрос 7 из 25

Что именно делает этот фрагмент неверным или неочевидным с точки зрения «Условные ветви»? Важно учесть: соответствие синтаксической конструкции методам построителя.

@resultBuilder enum OnlyBlock20 { static func buildBlock(_ x: String...) -> String { x.joined() } }
@OnlyBlock20 func text20(_ flag: Bool) -> String {
    if flag { "A" } else { "B" }
}

Код не компилируется: для условной ветви построитель не объявляет buildEither. Код проходит проверку типов: для условной ветви построитель не объявляет buildEither. Наблюдаемый симптом объясняется тем, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Код компилируется: для условной ветви построитель не объявляет buildEither. Первой нарушенной гарантией здесь является предположение, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип.

Вопрос 8 из 25

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

struct Field20: Equatable { let name: String }

@resultBuilder
enum FormBuilder20 {
    static func buildBlock(_ fields: Field20...) -> [Field20] { fields }
}

@FormBuilder20
func form20() -> [Field20] {
    Field20(name: "email")
    Field20(name: "age")
}

var global20: [Field20] = []
@FormBuilder20
func badForm20() -> [Field20] {
    global20.append(Field20(name: "x"))
    Field20(name: "y")
}

Проблема возникает из-за правила: порядок вызовов методов построителя не зависит от структуры исходного блока. Причина сбоя в том, что снимок итогового значения полностью заменяет тест отдельных преобразований. Код компилируется: append возвращает Void, для которого построитель не задаёт преобразование; кроме того, сама идея вводит скрытое общее состояние. Первой нарушенной гарантией здесь является предположение, что построитель результата исполняет DSL как интерпретатор во время выполнения. Код не компилируется: append возвращает Void, для которого построитель не задаёт преобразование; кроме того, сама идея вводит скрытое общее состояние.

Вопрос 9 из 25

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

import Foundation

@resultBuilder
enum IntBuilder20 {
    static func buildBlock(_ values: Int...) -> [Int] { values }
    static func buildExpression(_ value: Int) -> Int { value }
    static func buildExpression(_ value: String) -> Int { Int(value) ?? 0 }
}

@IntBuilder20
func broken20() -> [Int] {
    1
    Date()
}

Причина сбоя в том, что порядок вызовов методов построителя не зависит от структуры исходного блока. Отчёт об ошибке должен указывать, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Ошибка появляется внутри преобразования построителя, потому что для Date нет подходящего buildExpression. Проблема возникает из-за правила: ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Ошибка появляется вне преобразования построителя, потому что для Date нет подходящего buildExpression.

Вопрос 10 из 25

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

struct Field20: Equatable { let name: String }

@resultBuilder
enum FormBuilder20 {
    static func buildBlock(_ fields: Field20...) -> [Field20] { fields }
}

@FormBuilder20
func form20() -> [Field20] {
    Field20(name: "email")
    Field20(name: "age")
}

func test20() {
    let fields = form20()
    assert(fields.count == 2)
    assert(fields.map(\.name) == ["email", "age"])
}

Тест проверяет наблюдаемую структуру результата — число и порядок полей, — не привязываясь к внутренней последовательности вызовов построителя. Тест не проверяет наблюдаемую структуру результата — число и порядок полей, — не привязываясь к внутренней последовательности вызовов построителя. Отчёт об ошибке должен указывать, что порядок вызовов методов построителя не зависит от структуры исходного блока. Тест проверяет наблюдаемую структуру результата — число и порядок полей, — привязываясь к внутренней последовательности вызовов построителя. Наблюдаемый симптом объясняется тем, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение.

Вопрос 11 из 25

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

@resultBuilder enum B20 {
    static func buildBlock(_ values: Int...) -> [Int] { values }
}
@B20 func f20() -> [Int] { "x" }

Достаточно изменить работу с `B20`, исходя из того, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Добавить подходящий buildExpression только если String осмысленно входит в DSL, иначе исправить выражение на допустимый тип. Исправление — оставить контракт прежним и учитывать, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Добавить подходящий buildExpression только если String осмысленно не входит в DSL, иначе исправить выражение на допустимый тип. Нужно адаптировать только вызов `B20`, поскольку построитель результата исполняет DSL как интерпретатор во время выполнения.

Вопрос 12 из 25

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

@resultBuilder enum OnlyBlock20 { static func buildBlock(_ x: String...) -> String { x.joined() } }
@OnlyBlock20 func text20(_ flag: Bool) -> String {
    if flag { "A" } else { "B" }
}

Нужно адаптировать только вызов `OnlyBlock20`, поскольку `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Исправление — оставить контракт прежним и учитывать, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Достаточно изменить работу с `OnlyBlock20`, исходя из того, что порядок вызовов методов построителя не зависит от структуры исходного блока. Добавить buildEither для if/else, buildOptional для if без else или отказаться от условной конструкции в DSL. Правка сводится к локальному обходу: снимок итогового значения полностью заменяет тест отдельных преобразований.

Вопрос 13 из 25

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

struct Field20: Equatable { let name: String }

@resultBuilder
enum FormBuilder20 {
    static func buildBlock(_ fields: Field20...) -> [Field20] { fields }
}

@FormBuilder20
func form20() -> [Field20] {
    Field20(name: "email")
    Field20(name: "age")
}

var global20: [Field20] = []
@FormBuilder20
func badForm20() -> [Field20] {
    global20.append(Field20(name: "x"))
    Field20(name: "y")
}

Возвращать декларативные компоненты из тела, а побочные эффекты выполнять на неявном этапе интерпретации результата. Возвращать декларативные компоненты из тела, а побочные эффекты выполнять на явном этапе интерпретации результата. Достаточно изменить работу с `Field20`, исходя из того, что порядок вызовов методов построителя не зависит от структуры исходного блока. Сигнатуру можно не менять, если считать, что построитель результата исполняет DSL как интерпретатор во время выполнения. Правка сводится к локальному обходу: снимок итогового значения полностью заменяет тест отдельных преобразований.

Вопрос 14 из 25

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

import Foundation

@resultBuilder
enum IntBuilder20 {
    static func buildBlock(_ values: Int...) -> [Int] { values }
    static func buildExpression(_ value: Int) -> Int { value }
    static func buildExpression(_ value: String) -> Int { Int(value) ?? 0 }
}

@IntBuilder20
func broken20() -> [Int] {
    1
    Date()
}

Исправление — оставить контракт прежним и учитывать, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Свести тело к минимальному выражению и проверить сигнатуры buildExpression/buildBlock; не искать проблему сразу в итоговом типе функции. Свести тело к минимальному выражению и проверить сигнатуры buildExpression/buildBlock; искать проблему сразу в итоговом типе функции. Сигнатуру можно не менять, если считать, что снимок итогового значения полностью заменяет тест отдельных преобразований. Нужно адаптировать только вызов `IntBuilder20`, поскольку построитель результата исполняет DSL как интерпретатор во время выполнения.

Вопрос 15 из 25

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

struct Field20: Equatable { let name: String }

@resultBuilder
enum FormBuilder20 {
    static func buildBlock(_ fields: Field20...) -> [Field20] { fields }
}

@FormBuilder20
func form20() -> [Field20] {
    Field20(name: "email")
    Field20(name: "age")
}

func test20() {
    let fields = form20()
    assert(fields.count == 2)
    assert(fields.map(\.name) == ["email", "age"])
}

Правка сводится к локальному обходу: снимок итогового значения полностью заменяет тест отдельных преобразований. Сигнатуру можно не менять, если считать, что построитель результата исполняет DSL как интерпретатор во время выполнения. Добавить тесты пустого тела, условий, циклов buildArray и диагностически важных несовместимых выражений. Нужно адаптировать только вызов `Field20`, поскольку `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Достаточно изменить работу с `Field20`, исходя из того, что порядок вызовов методов построителя не зависит от структуры исходного блока.

Вопрос 16 из 25

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

Ограничение определяется предположением, что порядок вызовов методов построителя не зависит от структуры исходного блока. Построитель результата переписывает тело функции в последовательность статических методов; это не обычный интерпретатор DSL времени выполнения. Построитель результата переписывает тело функции в последовательность статических методов; это обычный интерпретатор DSL времени выполнения. Контрпример появляется, когда снимок итогового значения полностью заменяет тест отдельных преобразований. Граница применимости проходит там, где построитель результата исполняет DSL как интерпретатор во время выполнения.

Вопрос 17 из 25

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

Ограничение определяется предположением, что снимок итогового значения полностью заменяет тест отдельных преобразований. Правило меняется только в ситуации, где порядок вызовов методов построителя не зависит от структуры исходного блока. Пограничный случай связан с тем, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Обычный Swift if внутри result-построитель тела поддерживается только через набор методов, которые предоставляет конкретный построитель. Обычный Swift if вне result-построитель тела поддерживается только через набор методов, которые предоставляет конкретный построитель.

Вопрос 18 из 25

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

Построитель результата формирует значение; он не гарантирует чистоту, но чистый DSL проще повторно строить, сравнивать и тестировать. Ограничение определяется предположением, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Правило меняется только в ситуации, где `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Пограничный случай связан с тем, что построитель результата исполняет DSL как интерпретатор во время выполнения. Построитель результата формирует значение; он гарантирует чистоту, но чистый DSL проще повторно строить, сравнивать и тестировать.

Вопрос 19 из 25

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

Контрпример появляется, когда `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Сообщение компилятора не может указывать на всю построитель-функцию, хотя несовместимо одно выражение глубоко внутри тела. Сообщение компилятора может указывать на всю построитель-функцию, хотя несовместимо одно выражение глубоко внутри тела. Пограничный случай связан с тем, что порядок вызовов методов построителя не зависит от структуры исходного блока. Граница применимости проходит там, где ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение.

Вопрос 20 из 25

Какую предпосылку стоит явно записать в документации и тестах? Проверяется полнота тестов декларативного построителя.

Снимок отрисованного интерфейса заменяет тест структуры DSL, если порядок и идентификаторы компонентов имеют отдельный контракт. Пограничный случай связан с тем, что построитель результата исполняет DSL как интерпретатор во время выполнения. Снимок отрисованного интерфейса не заменяет тест структуры DSL, если порядок и идентификаторы компонентов имеют отдельный контракт. Правило меняется только в ситуации, где `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Снимок отрисованного интерфейса не заменяет тест классы DSL, если порядок и идентификаторы компонентов имеют отдельный контракт.

Вопрос 21 из 25

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

В API и тестах следует исходить из правила: построитель результата исполняет DSL как интерпретатор во время выполнения. Главным проектным принципом здесь является утверждение, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. Для устойчивого решения достаточно принять, что снимок итогового значения полностью заменяет тест отдельных преобразований. Чем больше неявных преобразований поддерживает построитель, тем хуже становятся сообщения компилятора и предсказуемость API. Чем больше неявных преобразований не поддерживает построитель, тем хуже становятся сообщения компилятора и предсказуемость API.

Вопрос 22 из 25

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

Условные возможности DSL не должны быть намеренными: поддержка каждой формы увеличивает поверхность ошибок и тестов. Для устойчивого решения достаточно принять, что снимок итогового значения полностью заменяет тест отдельных преобразований. Условные возможности DSL должны быть намеренными: поддержка каждой формы увеличивает поверхность ошибок и тестов. Архитектуру стоит строить из предположения, что порядок вызовов методов построителя не зависит от структуры исходного блока. Условные возможности DSL должны быть намеренными: поддержка каждой формы не увеличивает поверхность ошибок и тестов.

Вопрос 23 из 25

Что должно определять архитектуру этого участка, когда появятся новые входы и владельцы? Проверяется отделение описания от исполнения.

При расширении системы нужно опираться на то, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип. DSL оправдан, когда структура повторяется и читается лучше обычного кода; для двух вызовов построитель не может лишь спрятать контроль выполнения. DSL оправдан, когда структура повторяется и читается лучше обычного кода; для двух вызовов построитель может лишь спрятать контроль выполнения. DSL оправдан, когда класс повторяется и читается лучше обычного кода; для двух вызовов построитель может лишь спрятать контроль выполнения. Главным проектным принципом здесь является утверждение, что построитель результата исполняет DSL как интерпретатор во время выполнения.

Вопрос 24 из 25

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

Архитектуру стоит строить из предположения, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Главным проектным принципом здесь является утверждение, что построитель результата исполняет DSL как интерпретатор во время выполнения. Для сложного DSL полезны маленькие перегрузки и явные промежуточные типы: они делают диагностику локальнее. Для устойчивого решения достаточно принять, что порядок вызовов методов построителя не зависит от структуры исходного блока. При расширении системы нужно опираться на то, что `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип.

Вопрос 25 из 25

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

Построитель лучше тестировать на уровне результата и небольших преобразователей; привязка к деталям переписывания делает тест хрупким. При расширении системы нужно опираться на то, что порядок вызовов методов построителя не зависит от структуры исходного блока. Главным проектным принципом здесь является утверждение, что ошибка внутри блока всегда указывает на строку `buildBlock`, а не на исходное выражение. Построитель лучше тестировать на уровнутри результата и небольших преобразователей; привязка к деталям переписывания делает тест хрупким. В API и тестах следует исходить из правила: `buildEither` не нужен для условных ветвей, если обе ветви имеют одинаковый тип.