Перейти к содержимому
Топаздокументация

Поиск в документации

Спецификация 6.0

Выберите результат стрелками и нажмите Enter, чтобы открыть его.

Введите имя API, номер диагностики, правило или тему проекта.

    Загрузка →

    Проектные решения

    Выражения, образцы и поток управления

    Положительные значения пишутся без унарного плюса

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Перед числом или другим операндом можно было поставить +. Удаление этого знака не меняло значение.

    Решение

    Унарный + удалён. Операнд записывается непосредственно.

    Примеры

    Rejecting unary plus before an integer

    example.tpzRejecting unary plus before an integerОткрыть песочницу →
    1. let value = +1
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Rejecting unary plus before a bound value

    example.tpzRejecting unary plus before a bound valueОткрыть песочницу →
    1. let value = 1
    2. let copy = +value
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Rejecting unary plus before a float

    example.tpzRejecting unary plus before a floatОткрыть песочницу →
    1. let value = +1.5
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Using ordinary values, negation, and binary addition

    example.tpzUsing ordinary values, negation, and binary additionОткрыть песочницу →
    1. import std.io
    2. let value = 3
    3. io.writeLine("{1}")
    4. io.writeLine("{1.5}")
    5. io.writeLine("{value}")
    6. io.writeLine("{-value}")
    7. io.writeLine("{value + 2}")
    Ожидаемый выводКод завершения 0
    1
    1.5
    3
    -3
    5
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 1
    2. 1.5
    3. 3
    4. -3
    5. 5

    Рассмотренные варианты

    • Сохранить унарный +. У одного значения останутся два написания.

    Причина

    Запись унарной операции указывает на действие над значением.

    Изменённые правила Unary operators →

    In проверяет принадлежность массиву, множеству и диапазону

    Принято 7 ноября 2026 г. · 6.0.0 · В работе

    Проблема

    Оператор и метод могли отвечать на один вопрос о наличии элемента. Поиск подстроки и поиск ключа решают другие задачи.

    Решение

    • Используйте in для проверки элемента массива, множества или диапазона. Метод Set.contains удаляется.
    • Для проверки подстроки и поиска ключа остаются свои операции.

    Примеры

    Use in for arrays, sets, and ranges

    example.tpzUse in for arrays, sets, and rangesОткрыть песочницу →
    1. import std.io
    2. let values = [1, 3]
    3. let members = set { 1, 3 }
    4. let odds = 1..<5 by 2
    5. io.writeLine("{1 in values}:{2 in values}")
    6. io.writeLine("{1 in members}:{2 in members}")
    7. io.writeLine("{1 in odds}:{2 in odds}")
    Ожидаемый выводКод завершения 0
    true:false
    true:false
    true:false
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. true:false
    2. true:false
    3. true:false

    A Map is not an element-membership container

    example.tpzA Map is not an element-membership containerОткрыть песочницу →
    1. let found = "key" in map { "key": 1 }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Substring search is not element membership

    example.tpzSubstring search is not element membershipОткрыть песочницу →
    1. let found = "a" in "abc"
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Рассмотренные варианты

    • Оставить contains вместе с in. У одной проверки принадлежности сохранятся две формы.

    Причина

    По операции видно, проверяется ли элемент, подстрока или ключ.

    Изменённые правила Comparison and membership →

    Если получателя нет, аргументы необязательного вызова пропускаются

    Принято 18 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Аргумент может что-то вывести или вызвать ошибку даже при отсутствии получателя. Если вычислять его в таком случае, пропуск вызова даст неожиданный эффект.

    Решение

    • Получатель вычисляется один раз. При None() или null пропускаются поиск метода, аргументы, развёртка, создание обратного вызова и значения по умолчанию. Возвращается то же пустое значение.
    • Если значение есть, метод ищется на раскрытом значении, а дальше действует обычный порядок вызова.
    • Сигнатура и аргументы проверяются независимо от наличия получателя.
    • Результат Option не оборачивается дважды. У получателя с поддержкой null это значение остаётся отличимым.
    • Значением можно сделать только читающий метод встроенного типа. Попытка сделать значением изменяющий метод отклоняется.

    Примеры

    Option receiver, present

    example.tpzOption receiver, present
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: Option<P> = Some(P { x: 1 })
    7. let result: Option<int> = p?.plus(2)
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Option receiver, absent

    example.tpzOption receiver, absent
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: Option<P> = None()
    7. let result: Option<int> = p?.plus(2)
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Option result stays one layer

    example.tpzOption result stays one layer
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: Option<P> = Some(P { x: 1 })
    7. let result: Option<int> = p?.next()
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Nullable receiver, present

    example.tpzNullable receiver, present
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: P | null = P { x: 1 }
    7. let result: int | null = p?.plus(2)
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Nullable receiver, absent

    example.tpzNullable receiver, absent
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: P | null = null
    7. let result: int | null = p?.plus(2)
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Nullable receiver with Option return

    example.tpzNullable receiver with Option return
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: P | null = P { x: 1 }
    7. let result: Option<int> | null = p?.next()
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Absent receiver still checks member

    example.tpzAbsent receiver still checks memberОткрыть песочницу →
    1. record P { x: int }
    2. impl P {
    3. function plus(self, n: int) -> int { self.x + n }
    4. function next(self) -> Option<int> { Some(self.x + 1) }
    5. }
    6. let p: Option<P> = None()
    7. let result = p?.missing(1)
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Absent receiver skips argument expression

    example.tpzAbsent receiver skips argument expression
    1. import std.io
    2. record P { x: int }
    3. impl P { function plus(self, n: int) -> int { self.x + n } }
    4. function argument() -> int {
    5. io.writeLine("arg")
    6. 2
    7. }
    8. let p: Option<P> = None()
    9. let result = p?.plus(argument())
    10. io.writeLine("done")
    Ожидаемый выводКод завершения 0
    done
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. done

    Optional union checks every arm

    example.tpzOptional union checks every arm
    1. record A { x: int }
    2. record B { x: int }
    3. impl A { function plus(self, n: int) -> int { self.x + n } }
    4. impl B { function plus(self, n: string) -> int { self.x } }
    5. let value: (A | B) | null = null
    6. let result = value?.plus(2)
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Рассмотренные варианты

    • Оставить нынешний запрет ?. только для пользовательских методов. Встроенные и пользовательские методы подчинялись бы разным правилам, а одно намерение пришлось бы записывать длиннее через if let или match.
    • Запретить ?. и для встроенных методов. Спецификация уже описывает необязательный доступ общим правилом для членов.

    Причина

    Для встроенных и пользовательских методов по получателю видно, будут ли вычислены аргументы.

    Изменённые правила Member, index, and optional access →

    Поток данных выражается обычными вызовами и привязками

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    • Операторы |> и >>, а также _ в позиции выражения удаляются. Пользуйтесь обычными вызовами и функциями.
    • Показывайте порядок вычислений и повторное использование значений через let.

    Примеры

    Reject a pipeline placeholder

    example.tpzReject a pipeline placeholderОткрыть песочницу →
    1. function subtract(a: int, b: int) -> int { a - b }
    2. let value = 3 |> subtract(10, _)
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Reject the composition operator

    example.tpzReject the composition operatorОткрыть песочницу →
    1. function increment(n: int) -> int { n + 1 }
    2. function double(n: int) -> int { n * 2 }
    3. let composed = increment >> double
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Reject a standalone expression placeholder

    example.tpzReject a standalone expression placeholderОткрыть песочницу →
    1. let value = _
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Save values to preserve call and composition effects

    example.tpzSave values to preserve call and composition effectsОткрыть песочницу →
    1. import std.io
    2. function input() -> int {
    3. io.writeLine("input")
    4. 3
    5. }
    6. function subtract(a: int, b: int) -> int { a - b }
    7. function stage() -> (int, int) -> int {
    8. io.writeLine("callee")
    9. subtract
    10. }
    11. function argument() -> int {
    12. io.writeLine("argument")
    13. 10
    14. }
    15. let saved = input()
    16. let callee = stage()
    17. let written = argument()
    18. io.writeLine("{callee(written, saved)}")
    19. function increment(n: int) -> int { n + 1 }
    20. function double(n: int) -> int { n * 2 }
    21. function first() -> (int) -> int {
    22. io.writeLine("first")
    23. increment
    24. }
    25. function second() -> (int) -> int {
    26. io.writeLine("second")
    27. double
    28. }
    29. let left = first()
    30. let right = second()
    31. let composed = (n: int) => right(left(n))
    32. io.writeLine("{composed(3)}:{composed(5)}")
    Ожидаемый выводКод завершения 0
    input
    callee
    argument
    7
    first
    second
    8:12
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. input
    2. callee
    3. argument
    4. 7
    5. first
    6. second
    7. 8:12

    Рассмотренные варианты

    • Сохранить часть операторов конвейера или композиции. Вызов по-прежнему можно будет записать двумя способами.
    • Оставить все операторы. У одного вызова должен быть один способ записи.

    Причина

    По вызовам и привязкам видно, куда передаётся значение и когда оно вычисляется.

    Изменённые правила Ordinary calls and saved values →Compose calls in a function body →

    Управляющие выражения заключаются в скобки

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Запись или лямбда в заголовке может скрыть границу управляющего выражения. Особая грамматика заголовков затрудняет перенос обычных выражений.

    Решение

    • Заключайте управляющие выражения и условия в скобки, как в if (test), match (value) и while (test).
    • Шаблон диапазона пишется как (low .. high). В скобках действует обычный синтаксис выражений.

    Примеры

    Reject an undelimited if operand

    example.tpzReject an undelimited if operandОткрыть песочницу →
    1. let value = if true { 1 } else { 0 }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      control-operand-parentheses at example.tpz:1:16

    Record construction and update use ordinary operand grammar

    example.tpzRecord construction and update use ordinary operand grammarОткрыть песочницу →
    1. import std.io
    2. record Flag { enabled: bool }
    3. let state = { enabled: true }
    4. let first = if (Flag { enabled: true }.enabled) { 1 } else { 0 }
    5. let second = if (state { enabled: false }.enabled) { 1 } else { 2 }
    6. let third = match (Flag { enabled: true }) {
    7. case Flag { enabled: true } => true
    8. case _ => false
    9. }
    10. io.writeLine("{first},{second},{third}")
    Ожидаемый выводКод завершения 0
    1,2,true
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 1,2,true

    Reject an unwrapped range pattern

    example.tpzReject an unwrapped range patternОткрыть песочницу →
    1. let value = match (2) {
    2. case 1 .. 3 => 1
    3. case _ => 0
    4. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      range-pattern-parentheses at example.tpz:2:10

    A delimited range precedes a lambda-valued arm

    example.tpzA delimited range precedes a lambda-valued armОткрыть песочницу →
    1. import std.io
    2. let low = 1
    3. let high = 3
    4. let chosen = match (2) {
    5. case (low .. high) => (value: int) => value + 1
    6. case _ => (value: int) => value
    7. }
    8. io.writeLine("{chosen(6)}")
    Ожидаемый выводКод завершения 0
    7
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 7

    Рассмотренные варианты

    • Сохранить отдельную грамматику заголовков. При переносе выражения в заголовок действовали бы другие правила.
    • Изменить вместо этого сокращённую запись записей и лямбд. Грамматика выражений по-прежнему зависела бы от контекста.

    Причина

    Граница видна в коде, а синтаксис выражений везде одинаков.

    Изменённые правила Explicit control operands →Range pattern boundaries →

    Операнды вычисляются слева направо

    Принято 9 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Если оба операнда могут что-то вывести или завершиться с ошибкой, порядок меняет видимый результат. Определённый порядок показывает, какая ошибка появится первой.

    Решение

    • Операнды двоичных и вложенных выражений вычисляются слева направо. Сообщается первая ошибка выполнения.
    • При коротком замыкании вычисляются только нужные операнды. Аргументы, элементы коллекций и поля записей идут в порядке исходника.

    Примеры

    Binary and nested operands print from left to right

    example.tpzBinary and nested operands print from left to rightОткрыть песочницу →
    1. import std.io
    2. function value(label: string, number: int) -> int {
    3. io.writeLine(label)
    4. number
    5. }
    6. let result = value("left", 1) + value("middle", 2) * value("right", 3)
    7. io.writeLine("{result}")
    Ожидаемый выводКод завершения 0
    left
    middle
    right
    7
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. left
    2. middle
    3. right
    4. 7

    The left operand faults before the right operand runs

    example.tpzThe left operand faults before the right operand runsОткрыть песочницу →
    1. import std.io
    2. function left(divisor: int) -> int {
    3. io.writeLine("left")
    4. 1 / divisor
    5. }
    6. function right(number: int) -> int {
    7. io.writeLine("right")
    8. 9223372036854775807 + number
    9. }
    10. left(0) + right(1)
    Ожидаемый выводНенулевой код завершения
    left
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения run. Ненулевой код завершения.

    Ожидаемый стандартный вывод
    1. left

    Рассмотренные варианты

    • Оставить порядок вычисления неопределённым. Одна программа могла бы менять порядок вывода или первую ошибку.

    Причина

    Порядок вывода и ошибок читается непосредственно из кода.

    Изменённые правила Operand and assignment evaluation order →

    Решённые открытые вопросы Pending: remaining evaluation-order guarantees →

    Запись использует значение привязки после вычисления правой части

    Принято 16 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Правая часть индексного присваивания или аргумент изменяющего метода может переприсвоить переменную-получатель. От выбора значения для записи зависит результат.

    Решение

    • Индексное присваивание и изменяющий метод записывают в текущее значение привязки после вычисления правой части или аргументов.
    • Непосредственно перед записью позиция проверяется заново. Если shrink присваивает xs значение [7] и возвращает 5, после xs[0] = shrink() остаётся [5].

    Примеры

    A write uses the receiver after the arguments rebind it

    main.tpzA write uses the receiver after the arguments rebind itОткрыть песочницу →
    1. import std.io
    2. let mut xs = [1, 2]
    3. function shrink() -> int {
    4. xs = [7]
    5. 5
    6. }
    7. xs[0] = shrink()
    8. io.writeLine("{xs}")
    9. let mut ys = [3]
    10. function reset() -> int {
    11. ys = [0]
    12. 4
    13. }
    14. ys.push(reset())
    15. io.writeLine("{ys}")
    Ожидаемый выводКод завершения 0
    [5]
    [0, 4]
    
    $ topaz run main.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. [5]
    2. [0, 4]

    Рассмотренные варианты

    • Писать в значение, которое было привязано в начале вычисления. К этому моменту переменная уже указывает на новое значение, а запись идёт в оставленное старое.

    Причина

    Цель последней операции известна даже при переприсваивании в ходе вычисления.

    Изменённые правила Operand and assignment evaluation order →

    Числовые шаблоны принимают отрицательные литералы

    Принято 18 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Если положительные числа сравниваются напрямую, а отрицательные через диапазон или условие, одна проверка выглядит по-разному. Для знакового нуля также нужно единое сравнение.

    Решение

    • Перед числовым литералом в шаблоне допустим один -. Запись вроде -x и отдельный шаблон в скобках не допускаются.
    • Значение и ошибки совпадают с той же записью в выражении. При числовом сравнении -0.0 и 0.0 равны.
    • Ветвь для отрицательного нуля после охватывающей ветви для нуля без условия вызывает TPZ5713 при проверке.

    Примеры

    Negative numeric literal patterns preserve expression values

    example.tpzNegative numeric literal patterns preserve expression values
    1. import std.io
    2. function integer(value: int) -> int {
    3. match (value) {
    4. case -1 => 1
    5. case -0x8000000000000000 => 2
    6. case -1_000 => 3
    7. case -0 => 4
    8. case _ => 0
    9. }
    10. }
    11. function floating(value: float) -> int {
    12. match (value) {
    13. case -1.5 => 5
    14. case -0.0 => 6
    15. case _ => 0
    16. }
    17. }
    18. io.writeLine("{integer(-1)}")
    19. io.writeLine("{integer(-9223372036854775808)}")
    20. io.writeLine("{integer(-1000)}")
    21. io.writeLine("{integer(0)}")
    22. io.writeLine("{floating(-1.5)}")
    23. io.writeLine("{floating(0.0)}")
    Ожидаемый выводКод завершения 0
    1
    2
    3
    4
    5
    6
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6

    An earlier float zero case covers negative float zero

    example.tpzAn earlier float zero case covers negative float zero
    1. function classify(value: float) -> int {
    2. match (value) {
    3. case 0.0 => 1
    4. case -0.0 => 2
    5. case _ => 0
    6. }
    7. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    An earlier zero case covers negative zero

    example.tpzAn earlier zero case covers negative zero
    1. function classify(value: int) -> int {
    2. match (value) {
    3. case 0 => 1
    4. case -0 => 2
    5. case _ => 0
    6. }
    7. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    A standalone grouped negative literal pattern is rejected

    example.tpzA standalone grouped negative literal pattern is rejectedОткрыть песочницу →
    1. function classify(value: int) -> int {
    2. match (value) {
    3. case (-1) => 1
    4. case _ => 0
    5. }
    6. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    A repeated minus does not form a literal pattern

    example.tpzA repeated minus does not form a literal patternОткрыть песочницу →
    1. function classify(value: int) -> int {
    2. match (value) {
    3. case --1 => 1
    4. case _ => 0
    5. }
    6. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Рассмотренные варианты

    • Оставить отрицательные значения только в диапазонах и условиях. Для положительных и отрицательных чисел одна проверка записывалась бы по-разному.
    • Сравнивать нули побитово. Сопоставление разошлось бы с ==.

    Причина

    Правила для литералов и равенства одинаковы при любом знаке.

    Изменённые правила Pattern forms and name interpretation →

    Шаблон записи явно указывает поле и его подшаблон

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    Каждое поле шаблона записывается как field: pattern.

    Примеры

    Rejecting a structural field shorthand

    example.tpzRejecting a structural field shorthandОткрыть песочницу →
    1. let { value } = { value: 1 }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      record-pattern-field-colon at example.tpz:1:13

    Rejecting a nominal field shorthand

    example.tpzRejecting a nominal field shorthandОткрыть песочницу →
    1. record Point { x: int }
    2. let Point { x } = Point { x: 1 }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      record-pattern-field-colon at example.tpz:2:15

    Binding and renaming fields explicitly

    example.tpzBinding and renaming fields explicitlyОткрыть песочницу →
    1. import std.io
    2. record Point { x: int, y: int }
    3. let { value: value } = { value: 7 }
    4. let Point { x: first, y: second } = Point { x: 2, y: 3 }
    5. io.writeLine("{value} {first} {second}")
    Ожидаемый выводКод завершения 0
    7 2 3
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 7 2 3

    Рассмотренные варианты

    • Разрешить сокращение до одного имени с особыми ограничениями. У одной привязки будут две формы, а для сокращения понадобятся отдельные правила.

    Причина

    В коде видны и поле, и шаблон для его значения.

    Изменённые правила Pattern forms and name interpretation →

    Пропущенное двоеточие в шаблоне записи является ошибкой разбора

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    TPZ5611 зарезервирован для защитной проверки. Пропуск двоеточия вызывает TPZ2001 при разборе.

    Примеры

    Rejecting a structural field shorthand →

    Rejecting a nominal field shorthand →

    Рассмотренные варианты

    • Добавить достижимое условие проверки с TPZ5611. Та же ошибочная запись уже отклоняется при разборе.

    Причина

    Ошибка формы поля обнаруживается при чтении исходника.

    Изменённые правила Pattern forms and name interpretation →

    Для возврата из функции ветвь сопоставления использует блок

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    После стрелки ветви стоит выражение результата. Иногда из ветви нужно завершить всю функцию. Прямой return смешал бы выражения и операторы.

    Решение

    Помещайте return в блок внутри ветви сопоставления.

    Примеры

    Rejecting a return without an arm block

    example.tpzRejecting a return without an arm blockОткрыть песочницу →
    1. function choose(flag: bool) -> int {
    2. while (true) {
    3. let value = match (flag) {
    4. case true => return 7
    5. case false => 3
    6. }
    7. return value
    8. }
    9. 0
    10. }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      match-arm-return-needs-block at example.tpz:4:26

    Returning through a match arm block

    example.tpzReturning through a match arm blockОткрыть песочницу →
    1. import std.io
    2. function choose(flag: bool) -> int {
    3. while (true) {
    4. let value = match (flag) {
    5. case true => { return 7 }
    6. case false => 3
    7. }
    8. return value
    9. }
    10. 0
    11. }
    12. io.writeLine("{choose(true)}")
    13. io.writeLine("{choose(false)}")
    Ожидаемый выводКод завершения 0
    7
    3
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 7
    2. 3

    Рассмотренные варианты

    • Разрешить в ветви отдельную форму return без блока. Для одного и того же оператора появится исключение, действующее лишь в ветви.
    • Разрешить return как выражение в любом месте. Должно действовать одно правило, что return является оператором.

    Причина

    Возврат из блока подчиняется обычному синтаксису операторов.

    Изменённые правила Case selection and guards →

    Сопоставление выбирает первую подходящую ветвь и отклоняет перекрытые

    Принято 8 ноября 2026 г. · 6.0.0 · В работе · Версия 2

    Проблема

    Особый случай часто обрабатывается перед общим правилом. Запрет любого пересечения вынуждает переписывать ветви или добавлять условия.

    Решение

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

    Примеры

    A repeated unguarded literal case is unreachable

    example.tpzA repeated unguarded literal case is unreachable
    1. function choose(value: int) -> int {
    2. match (value) {
    3. case 1 => 10
    4. case 1 => 20
    5. case _ => 0
    6. }
    7. }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    Overlapping guarded cases follow source order

    example.tpzOverlapping guarded cases follow source orderОткрыть песочницу →
    1. import std.io
    2. function choose(value: int) -> string {
    3. match (value) {
    4. case number if (number > 0) => "positive"
    5. case number if (number <= 0) => "nonpositive"
    6. case _ => "other"
    7. }
    8. }
    9. io.writeLine(choose(4))
    10. io.writeLine(choose(0))
    Ожидаемый выводКод завершения 0
    positive
    nonpositive
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. positive
    2. nonpositive

    A later wildcard is covered by two earlier unguarded cases

    example.tpzA later wildcard is covered by two earlier unguarded cases
    1. let value: bool = true
    2. let result = match (value) {
    3. case true => "yes"
    4. case false => "no"
    5. case _ => "hidden"
    6. }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    Cover all payloads of a constructor with two bool fields

    example.tpzCover all payloads of a constructor with two bool fields
    1. enum E { Pair(bool, bool), Empty }
    2. function f(e: E) -> int { match (e) { case Pair(_, true) => 1
    3. case Pair(_, false) => 2
    4. case Empty() => 3 } }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Рассмотренные варианты

    • Запрещать пересечение независимо от порядка ветвей. Порядок записи не мог бы прямо выразить намерение сначала обработать исключение.

    Причина

    Особые случаи можно поставить раньше, а проверка найдёт ветви, до которых выполнение не дойдёт.

    Изменённые правила Case selection and guards →Reachable overlapping cases →

    История версий
    • Версия 1 · Принято 7 ноября 2026 г. · Первое решение требовало непересекающихся явных шаблонов

      Сначала приняли симметричную проверку пересечений и единственную запасную ветвь.

    Диапазон с двумя литеральными концами, которому не соответствует ни одно значение, отклоняется при проверке

    Принято 18 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    • Если обе границы заданы целыми литералами, сначала выполняется обычная проверка литералов.
    • Для (a ..< b) при a >= b и для (a .. b) при a > b проверка выдаёт TPZ5714. Это правило действует и для литералов в скобках, и для вложенных шаблонов.
    • Пустой диапазон с вычисляемыми границами при выполнении просто не совпадает со значением.

    Примеры

    An exclusive literal range with equal endpoints is rejected

    example.tpzAn exclusive literal range with equal endpoints is rejected
    1. function classify(value: int) -> int {
    2. match (value) {
    3. case (0 ..< 0) => 1
    4. case _ => 0
    5. }
    6. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    A reversed inclusive literal range is rejected

    example.tpzA reversed inclusive literal range is rejected
    1. function classify(value: int) -> int {
    2. match (value) {
    3. case (5 .. 1) => 1
    4. case _ => 0
    5. }
    6. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    An empty range is rejected inside a reachable alternative

    example.tpzAn empty range is rejected inside a reachable alternative
    1. function classify(value: int) -> int {
    2. match (value) {
    3. case (0 ..< 0) | 1 => 1
    4. case _ => 0
    5. }
    6. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    A for pattern rejects a static empty range

    example.tpzA for pattern rejects a static empty range
    1. for (0 ..< 0) in ([0]) {
    2. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    A computed empty range fails to match at runtime

    example.tpzA computed empty range fails to match at runtimeОткрыть песочницу →
    1. import std.io
    2. function endpoint(value: int) -> int { value }
    3. let result = match (0) {
    4. case (endpoint(0) ..< endpoint(0)) => 1
    5. case _ => 2
    6. }
    7. io.writeLine("{result}")
    Ожидаемый выводКод завершения 0
    2
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 2

    Рассмотренные варианты

    • Использовать TPZ5713, ошибку уже охваченной ветви. Тогда диагностика могла бы ошибочно указать на предыдущую ветвь.
    • Считать пустой литеральный диапазон обычным несовпадением. Из-за опечатки в границе участок кода останется недостижимым без сообщения.

    Причина

    Ошибка указывает на диапазон даже внутри достижимой ветви.

    Изменённые правила Integer range patterns →

    Вычисляемые границы выполняются при каждой проверке диапазона

    Принято 17 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    • Дойдя до диапазона, сопоставление вычисляет нижнюю границу, затем верхнюю. При каждой проверке вычисление повторяется.
    • Сначала проверяются внешние шаблоны, затем альтернативы слева направо. После первого совпадения проверяется условие ветви. При ложном условии проверяется следующая ветвь.
    • Этот порядок действует в match, for и при разборе значения. Ошибка или ? в достигнутой границе подчиняется обычному порядку управления.

    Примеры

    A successful range alternative skips later endpoints

    example.tpzA successful range alternative skips later endpoints
    1. import std.io
    2. function bound(value: int) -> int { value }
    3. function boom(divisor: int) -> int { 1 / divisor }
    4. let chosen = match (0) {
    5. case (0 .. bound(1)) | (0 .. boom(0)) => 7
    6. case _ => 9
    7. }
    8. io.writeLine("{chosen}")
    Ожидаемый выводКод завершения 0
    7
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 7

    A false guard continues with the next case

    example.tpzA false guard continues with the next case
    1. import std.io
    2. function end(label: string) -> int {
    3. io.writeLine(label)
    4. 1
    5. }
    6. let chosen = match (0) {
    7. case (0 .. 1) | (0 .. end("or")) if (false) => 1
    8. case (0 .. end("next")) => 2
    9. case _ => 9
    10. }
    11. io.writeLine("{chosen}")
    Ожидаемый выводКод завершения 0
    next
    2
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. next
    2. 2

    A for pattern evaluates endpoints for each element

    example.tpzA for pattern evaluates endpoints for each element
    1. import std.io
    2. function high() -> int {
    3. io.writeLine("high")
    4. 1
    5. }
    6. for (0 .. high()) in ([1, 1]) {
    7. io.writeLine("matched")
    8. }
    Ожидаемый выводКод завершения 0
    high
    matched
    high
    matched
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. high
    2. matched
    3. high
    4. matched

    A reached endpoint failure stops matching

    example.tpzA reached endpoint failure stops matchingОткрыть песочницу →
    1. import std.io
    2. function boom(divisor: int) -> int {
    3. io.writeLine("boom")
    4. 1 / divisor
    5. }
    6. let chosen = match (0) {
    7. case (0 .. boom(0)) => 7
    8. case _ => 9
    9. }
    10. io.writeLine("{chosen}")
    Ожидаемый выводНенулевой код завершения
    boom
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения run. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    Ожидаемый стандартный вывод
    1. boom

    Рассмотренные варианты

    • Заранее вычислять все границы ветви. Ошибка в неиспользуемой альтернативе могла бы прервать выбранный путь.
    • Разрешить только константные границы. Тогда уже существующие программы с вычисляемыми диапазонами пришлось бы отклонять.

    Причина

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

    Изменённые правила Integer range patterns →

    Хвост списка получает явный подшаблон

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    После .. всегда пишется шаблон. Чтобы отбросить хвост, используйте .._.

    Примеры

    Rejecting a rest marker without a pattern

    example.tpzRejecting a rest marker without a patternОткрыть песочницу →
    1. let count = match ([1, 2]) {
    2. case [..] => 2
    3. }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      list-rest-pattern-required at example.tpz:2:13

    Rejecting an omitted middle rest pattern

    example.tpzRejecting an omitted middle rest patternОткрыть песочницу →
    1. let total = match ([1, 2, 3]) {
    2. case [first, .., last] => first + last
    3. case _ => 0
    4. }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2001 →

      list-rest-pattern-required at example.tpz:2:20

    Ignoring a rest with an explicit wildcard

    example.tpzIgnoring a rest with an explicit wildcardОткрыть песочницу →
    1. import std.io
    2. let middle = match ([1, 2, 3, 4]) {
    3. case [first, .._, last] => "{first} {last}"
    4. case _ => "miss"
    5. }
    6. let leading = match ([1, 2, 3, 4]) {
    7. case [.._, last] => last
    8. case _ => 0
    9. }
    10. let trailing = match ([1, 2, 3, 4]) {
    11. case [first, .._] => first
    12. case _ => 0
    13. }
    14. let empty: Array<int> = []
    15. let ignored = match (empty) {
    16. case [.._] if (empty.length == 0) => true
    17. case _ => false
    18. }
    19. io.writeLine(middle)
    20. io.writeLine("{leading}")
    21. io.writeLine("{trailing}")
    22. io.writeLine("{ignored}")
    Ожидаемый выводКод завершения 0
    1 4
    4
    1
    true
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 1 4
    2. 4
    3. 1
    4. true

    Рассмотренные варианты

    • Отбрасывать остаток только голым .. и отклонять .._. Связывание (..rest) и отбрасывание (.._) должны следовать одному правилу.
    • Разрешить и голый .., и .._. Появилось бы два способа отбросить остаток.

    Причина

    Формы ..rest и .._ устроены одинаково и показывают, что происходит с остатком.

    Изменённые правила A single list rest and its surrounding elements →

    Даже конструкторы без аргументов пишутся со скобками

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Если скобки зависят от наличия данных, читателю приходится искать объявление. Отдельное имя в шаблоне также можно принять за новую привязку.

    Решение

    • В значениях и шаблонах пишите скобки у конструкторов, как в None(), Empty() и Some(x).
    • Привязка с именем конструктора отклоняется.

    Примеры

    Constructor patterns keep parentheses at every arity

    example.tpzConstructor patterns keep parentheses at every arityОткрыть песочницу →
    1. import std.io
    2. enum Choice { Empty, Filled(int), Pair(int, int) }
    3. function read(value: Choice) -> int {
    4. match (value) {
    5. case Empty() => 0
    6. case Filled(number) => number
    7. case Pair(left, right) => left + right
    8. }
    9. }
    10. function nested(value: Option<Choice>) -> int {
    11. match (value) {
    12. case None() => -1
    13. case Some(Empty()) => 0
    14. case Some(Filled(number)) => number
    15. case Some(Pair(left, right)) => left + right
    16. }
    17. }
    18. io.writeLine("{read(Choice.Empty())}")
    19. io.writeLine("{read(Choice.Filled(7))}")
    20. io.writeLine("{read(Choice.Pair(2, 3))}")
    21. io.writeLine("{nested(None())}")
    22. io.writeLine("{nested(Some(Choice.Empty()))}")
    Ожидаемый выводКод завершения 0
    0
    7
    5
    -1
    0
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 0
    2. 7
    3. 5
    4. -1
    5. 0

    None needs parentheses in a constructor pattern

    example.tpzNone needs parentheses in a constructor patternОткрыть песочницу →
    1. function read(value: Option<int>) -> int {
    2. match (value) {
    3. case Some(number) => number
    4. case None => 0
    5. }
    6. }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2012 →

      pattern-reserved-none-binding at example.tpz:4:14

    None needs parentheses in a constructor value

    example.tpzNone needs parentheses in a constructor valueОткрыть песочницу →
    1. let maybe: Option<int> = None
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    • TPZ2012 →

      pattern-reserved-none-binding at example.tpz:1:26

    Qualified constructor patterns are rejected

    example.tpzQualified constructor patterns are rejectedОткрыть песочницу →
    1. enum Choice { Empty }
    2. let value: Choice = Choice.Empty()
    3. let result = match (value) {
    4. case Choice.Empty => 1
    5. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Контракт обязательного основного местоположения не определён.

    A qualified nullary constructor keeps its parentheses

    example.tpzA qualified nullary constructor keeps its parenthesesОткрыть песочницу →
    1. enum Choice { Empty }
    2. let value: Choice = Choice.Empty()
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Проверка принимает программу. Код завершения 0.

    Рассмотренные варианты

    • Записывать конструкторы без аргументов одним именем. Роль имени зависела бы от объявления и позиции использования.
    • Разрешить оба написания. У одного конструктора было бы два написания.
    • Требовать скобки только в образцах. Одно и то же имя выглядело бы по-разному в зависимости от места.

    Причина

    Форма конструктора одинакова при любом числе аргументов и в любой из этих позиций.

    Изменённые правила Constructor syntax and binding names →Variants without payloads →

    Выражение match охватывает все возможные значения

    Принято 9 ноября 2026 г. · 6.0.0 · В работе

    Проблема

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

    Решение

    • Проверка требует, чтобы каждое выражение match охватывало все возможные значения.
    • Для перечислений, Option, Result, bool и закрытых объединений нужны все случаи. Это требование распространяется и на значения закрытых типов внутри конструктора.
    • Для открытых типов, включая целые и вещественные числа, строки, массивы, диапазоны и параметры типа, последняя ветвь должна быть без условия.
    • Ветви с условием не учитываются при проверке полноты.
    • Если случай пропущен, проверка выдаёт TPZ5021. В Topaz 6.0.0 прежняя ошибка выполнения TPZ4006 упразднена.

    Примеры

    Option bool covers both payloads and None

    example.tpzOption bool covers both payloads and NoneОткрыть песочницу →
    1. import std.io
    2. function read(value: Option<bool>) -> int {
    3. match (value) {
    4. case Some(true) => 1
    5. case Some(false) => 0
    6. case None() => -1
    7. }
    8. }
    9. let flags = map { "on": true, "off": false }
    10. io.writeLine("{read(flags.get("on"))}")
    11. io.writeLine("{read(flags.get("off"))}")
    12. io.writeLine("{read(flags.get("missing"))}")
    Ожидаемый выводКод завершения 0
    1
    0
    -1
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 1
    2. 0
    3. -1

    Cover all payloads of a constructor with two bool fields →

    Рассмотренные варианты

    • Проверять закрытые типы, а для открытых выдавать ошибку при выполнении. Код с пропущенной ветвью пройдёт проверку и сможет остановиться на редких входных данных.
    • Задать правило для bool и отложить остальные типы. Для перечислений и объединений не будет общего правила, по которому можно определить нужные ветви.

    Причина

    Пропущенные случаи видны при проверке кода до выполнения. Сопоставлению по открытому типу нужна последняя безусловная ветвь, которая принимает все оставшиеся значения.

    Изменённые правила Every match is exhaustive →Reserved runtime code and current checking diagnostic →Non-exhaustive match →

    Решённые открытые вопросы Complete exhaustiveness contract →

    For выполняет действия, а генератор собирает значения

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Цикл в позиции значения мог собирать результаты в массив. Перенос того же цикла менял тип результата.

    Решение

    • Цикл for выполняет действия и возвращает () в любом контексте.
    • Чтобы собрать результаты в массив, используйте генератор.

    Примеры

    For results stay unit in grouped and bound positions

    example.tpzFor results stay unit in grouped and bound positions
    1. import std.io
    2. function items(label: string) -> Array<int> {
    3. io.writeLine(label)
    4. [1, 2]
    5. }
    6. let bound = for item in (items("bound")) {
    7. io.writeLine("{item}")
    8. item * 2
    9. }
    10. let grouped = (for item in (items("grouped")) {
    11. io.writeLine("{item}")
    12. item * 3
    13. })
    14. let emptyItems: Array<int> = []
    15. let empty = for item in (emptyItems) { item }
    16. io.writeLine("{bound} {grouped} {empty}")
    Ожидаемый выводКод завершения 0
    bound
    1
    2
    grouped
    1
    2
    () () ()
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. bound
    2. 1
    3. 2
    4. grouped
    5. 1
    6. 2
    7. () () ()

    For cannot supply an array result

    example.tpzFor cannot supply an array result
    1. let values: Array<int> = for item in ([1, 2]) { item * 2 }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения check. Ненулевой код завершения.

    • TPZ5001 →

      for-result-type-mismatch at example.tpz:1:26

    Collect values with an array comprehension

    example.tpzCollect values with an array comprehensionОткрыть песочницу →
    1. import std.io
    2. let values: Array<int> = [for item in ([1, 2]) => item * 2]
    3. io.writeLine("{values[0]} {values[1]}")
    Ожидаемый выводКод завершения 0
    2 4
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. 2 4

    Рассмотренные варианты

    • Собирать массив, если for стоит в позиции значения. Один и тот же цикл выполнял бы разную работу в зависимости от места записи.

    Причина

    По синтаксису видно, собираются ли значения или выполняются действия. Сбор с досрочной остановкой записывают через накопитель и break, а сбор без остановки записывают включением.

    Изменённые правила Statement and value uses of for →

    Диагностика defer предлагает записать блок

    Принято 16 ноября 2026 г. · 6.0.0 · В работе

    Проблема

    Отклоняя defer f(), сообщение могло по-прежнему предлагать отдельный вызов. Такой совет не помогал исправить программу.

    Решение

    • При разборе TPZ2004 сообщает, что defer требует блока, и указывает на начало выражения тела.
    • Пример исправления приводится в документации диагностики.

    Примеры

    Rejecting a deferred call without a block

    example.tpzRejecting a deferred call without a blockОткрыть песочницу →
    1. import std.io
    2. function finish() -> () {
    3. defer io.writeLine("cleanup")
    4. }
    5. finish()
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения parse. Ненулевой код завершения.

    Рассмотренные варианты

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

    Причина

    Из сообщения понятно, что отложенную работу нужно поместить в блок.

    Изменённые правила Registering a deferred block →

    Отложенный код помещается в блок defer

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    Отложенную работу можно было записать блоком или отдельным вызовом. У одной операции были две формы записи.

    Решение

    После defer укажите блок. Запись defer f() без блока отклоняется при разборе.

    Примеры

    Rejecting a deferred call without a block →

    Running a deferred block at scope exit

    example.tpzRunning a deferred block at scope exitОткрыть песочницу →
    1. import std.io
    2. function finish() -> () {
    3. defer { io.writeLine("cleanup") }
    4. io.writeLine("body")
    5. }
    6. finish()
    Ожидаемый выводКод завершения 0
    body
    cleanup
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. body
    2. cleanup

    Рассмотренные варианты

    • Сохранить и блоки, и отдельные вызовы. Один отложенный фрагмент по-прежнему можно было бы записать двумя способами.

    Причина

    В блоке видны границы отложенного кода. Форма вызова вычисляла аргументы при регистрации, а не при очистке. Чтобы сохранить текущее значение, его явно связывают через let.

    Изменённые правила Registering a deferred block →

    Управление не может перейти через границу defer

    Принято 19 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    • Если return, break, continue или ? пересекает границу defer, проверка сообщает TPZ5001 на самом выражении, даже в недостижимом коде.
    • Возврат и передача ошибки из функции, объявленной внутри очистки, как и переходы внутри её собственного цикла, допустимы в пределах соответствующего блока.
    • Во вложенной очистке правило применяется к каждой пересечённой границе defer.

    Рассмотренные варианты

    • Назначить приоритеты переходам во время очистки. Переход сможет подменить уже начатый возврат или скрыть другую операцию очистки.

    Причина

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

    Изменённые правила Cleanup order on normal completion and control transfer →Runtime faults skip remaining cleanup →

    Возврат значения ошибки тоже выполняет зарегистрированную очистку

    Принято 7 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

    При распространении Err через ? функция завершается до конца блока. Для уже зарегистрированной очистки нужен определённый порядок.

    Решение

    • При возврате Err через ? блоки defer выполняются в обратном порядке регистрации для покидаемых областей. Ok из области не выходит.
    • Автоматическое закрытие через using следует тому же правилу выхода.

    Примеры

    Cleaning up scopes during error propagation

    example.tpzCleaning up scopes during error propagationОткрыть песочницу →
    1. import std.io
    2. function fail() -> Result<int, string> {
    3. io.writeLine("operand")
    4. Err("stop")
    5. }
    6. function finish() -> Result<int, string> {
    7. defer { io.writeLine("outer") }
    8. let value = {
    9. defer { io.writeLine("inner-first") }
    10. defer { io.writeLine("inner-second") }
    11. fail()?
    12. }
    13. io.writeLine("unreachable")
    14. Ok(value)
    15. }
    16. io.writeLine(match (finish()) {
    17. case Ok(value) => "value={value}"
    18. case Err(error) => error
    19. })
    Ожидаемый выводКод завершения 0
    operand
    inner-second
    inner-first
    outer
    stop
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Выполнение завершается. Код завершения 0.

    Ожидаемый стандартный вывод
    1. operand
    2. inner-second
    3. inner-first
    4. outer
    5. stop

    Рассмотренные варианты

    • Пропускать defer при передаче ошибки через ?. Одна и та же очистка по-разному вела бы себя при обычном и досрочном выходе.
    • Выполнять очистку только для using как особый случай. Очистке нужно одно правило при любом способе выхода из области.

    Причина

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

    Изменённые правила Cleanup order on normal completion and control transfer →Using acquisition and cleanup order →

    Невосстановимая ошибка выполнения пропускает оставшуюся очистку

    Принято 9 ноября 2026 г. · 6.0.0 · Проверяется

    Проблема

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

    Решение

    Обычная ошибка выполнения завершает исполнение без возможности продолжения. Оставшаяся очистка defer и using пропускается.

    Примеры

    A runtime fault leaves defer output absent

    example.tpzA runtime fault leaves defer output absentОткрыть песочницу →
    1. import std.io
    2. function divide(divisor: int) -> int {
    3. defer { io.writeLine("cleanup") }
    4. io.writeLine("before fault")
    5. 12 / divisor
    6. }
    7. io.writeLine("{divide(0)}")
    Ожидаемый выводНенулевой код завершения
    before fault
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

    Ожидаемый результат

    Этап отклонения run. Ненулевой код завершения.

    Ожидаемый стандартный вывод
    1. before fault

    Рассмотренные варианты

    • Выполнять оставшуюся очистку после ошибки. После первой ошибки мог бы появиться новый вывод или ещё одна ошибка.
    • Не гарантировать очистку при сбое. Поведение должно быть определено, чтобы программа повторяла свой вывод.

    Причина

    По первой ошибке видно, где останавливается выполнение.

    Изменённые правила Runtime faults skip remaining cleanup →

    Частично решённые открытые вопросы Pending: complete defer contexts and abrupt exits →

    История версий