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

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

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

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

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

    Загрузка →

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

    Лексика и литералы

    Формат конца строки сохраняет границы операторов

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

    Проблема

    Редакторы могут сохранить один и тот же файл с LF, CRLF или CR. Если один вариант считать пробелом, границы операторов могут сместиться.

    Решение

    • LF, CRLF и одиночный CR означают один перевод строки в исходнике.
    • Все физические переводы строки внутри блочного комментария тоже сохраняются как та же граница оператора. Позже заменено решением Комментарии пишутся по одной строке →

    Примеры

    CRLF separates completed statements

    example.tpzCRLF separates completed statementsОткрыть песочницу →
    1. import std.io
    2. let value = 1
    3. -2
    4. io.writeLine("{value}")
    Ожидаемый выводКод завершения 0
    1
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Bare CR separates completed statements

    example.tpzBare CR separates completed statementsОткрыть песочницу →
    1. import std.io
    2. let value = 1 -2
    3. io.writeLine("{value}")
    Ожидаемый выводКод завершения 0
    1
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Bare CR ends a line comment

    example.tpzBare CR ends a line commentОткрыть песочницу →
    1. import std.io
    2. // comment io.writeLine("after")
    3. io.writeLine("tail")
    Ожидаемый выводКод завершения 0
    after
    tail
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

    • Считать одиночный CR горизонтальным пробелом. Смена формата конца строки могла бы изменить границы операторов.

    Причина

    Одни и те же операторы сохраняют смысл в файлах из разных редакторов и операционных систем.

    Изменённые правила Horizontal space and newlines →Statement boundaries →

    Решённые открытые вопросы Carriage returns and comment-contained line breaks →

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

    Бывшее начало блочного комментария подчиняется правилам операторов

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

    Проблема

    Запись /* в начале строки похожа на начало комментария. Если читать её как два оператора, нужно указать, на каком токене синтаксис нарушен.

    Решение

    • Анализатор читает /* как / и *. Если на предыдущей строке есть выражение, / продолжает его, а TPZ2001 указывает на *, где ожидался операнд.
    • В начале программы без предыдущего выражения ошибка указывает на сам /.

    Примеры

    The retired block opener is rejected without a closer

    example.tpzThe retired block opener is rejected without a closerОткрыть песочницу →
    1. let value: int = 1
    2. /* unfinished
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    • Прерывать выражение перед / в начале строки. Перенос строки до или после деления мог бы изменить смысл выражения.
    • Ввести для /* особую диагностику. Для удалённой записи снова понадобятся отдельный токен и правило.

    Причина

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

    Изменённые правила Block comment spellings are rejected →Statement boundaries →

    Комментарии пишутся по одной строке

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

    Проблема

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

    Решение

    • Комментарий начинается с // и заканчивается в конце строки.
    • Блочных комментариев /* */ нет.

    Примеры

    A block comment on one line is rejected

    example.tpzA block comment on one line is rejectedОткрыть песочницу →
    1. import std.io
    2. let value = 1 /* no line break */ +2
    3. io.writeLine("{value}")
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Parentheses do not admit block comments

    example.tpzParentheses do not admit block commentsОткрыть песочницу →
    1. import std.io
    2. let value = (1 /* before after */ +2)
    3. io.writeLine("{value}")
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

    Причина

    Длинное пояснение можно записать несколькими строками с //. Короткое пояснение в середине строки сохраняет смысл и на строке выше.

    Изменённые правила Block comment spellings are rejected →

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

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

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

    Проблема

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

    Решение

    • Разделяйте операторы переводом строки. Точка с запятой не используется.
    • Чтобы отбросить значение, пишите let _ = expression. Перевод строки, пустая строка или комментарий перед закрывающей скобкой сохраняют итоговое значение блока.

    Примеры

    A semicolon cannot discard a block tail

    example.tpzA semicolon cannot discard a block tailОткрыть песочницу →
    1. function value() { 7; }
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    • TPZ2001 →

      expected-statement-separator at example.tpz:1:21

    A semicolon cannot separate program items

    example.tpzA semicolon cannot separate program itemsОткрыть песочницу →
    1. let first = 1; let second = 2
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    • TPZ2001 →

      expected-statement-separator at example.tpz:1:14

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

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

    Причина

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

    Изменённые правила Statement boundaries →

    Идентификаторы записываются в NFC

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

    Проблема

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

    Решение

    • Записывайте идентификаторы в NFC по Unicode 16. После первого символа допустимы комбинируемые символы Mn, Mc и Me. Символы, игнорируемые по умолчанию, исключены.
    • Скалярные значения строки и данные UTF-8 сохраняются.

    Примеры

    Use the NFC spelling throughout the source

    example.tpzUse the NFC spelling throughout the sourceОткрыть песочницу →
    1. let café: int = 1
    2. let 가: int = 2
    3. let K: int = 3
    4. let value: int = café + 가 + K
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Reject decomposed source names

    example.tpzReject decomposed source namesОткрыть песочницу →
    1. let café = 1
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Combining marks continue NFC names

    example.tpzCombining marks continue NFC namesОткрыть песочницу →
    1. let q́: int = 1
    2. let का: int = q́
    3. let x⃝: int = का
    4. loop 'q́ { break 'q́ }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Reject an invisible Hangul filler in a name

    example.tpzReject an invisible Hangul filler in a nameОткрыть песочницу →
    1. let aㅤ = 1
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Preserve composed, decomposed, and invisible string data

    example.tpzPreserve composed, decomposed, and invisible string dataОткрыть песочницу →
    1. import std.io
    2. let composed = "é"
    3. let decomposed = "é"
    4. let hangul = "가"
    5. let invisible = "a͏‍️"
    6. let inserted = "{decomposed}"
    7. io.writeLine(composed.encodeUtf8().toHex())
    8. io.writeLine(decomposed.encodeUtf8().toHex())
    9. io.writeLine(hangul.encodeUtf8().toHex())
    10. io.writeLine(invisible.encodeUtf8().toHex())
    11. io.writeLine(inserted.encodeUtf8().toHex())
    Ожидаемый выводКод завершения 0
    c3a9
    65cc81
    e18480e185a1
    61cd8fe2808defb88f
    65cc81
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. c3a9
    2. 65cc81
    3. e18480e185a1
    4. 61cd8fe2808defb88f
    5. 65cc81

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

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

    Причина

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

    Изменённые правила Canonical source spelling →Identifier characters →Preserved Unicode string data →

    Префиксы и шестнадцатеричные цифры пишутся строчными

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

    Проблема

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

    Решение

    • Для двоичных чисел пишите 0b, для шестнадцатеричных 0x. Оба префикса строчные.
    • Шестнадцатеричные цифры от a до f тоже строчные.

    Примеры

    Reject uppercase hex prefix

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

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

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

    • TPZ2001 →

      malformed-numeric-literal at example.tpz:1:13

    Reject uppercase binary prefix

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

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

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

    • TPZ2001 →

      malformed-numeric-literal at example.tpz:1:13

    Reject uppercase hex digit

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

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

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

    • TPZ2001 →

      malformed-numeric-literal at example.tpz:1:13

    Read lowercase radix literals

    example.tpzRead lowercase radix literalsОткрыть песочницу →
    1. import std.io { writeLine }
    2. writeLine("{0xff}")
    3. writeLine("{0b1010}")
    4. writeLine("{0xabcdef}")
    Ожидаемый выводКод завершения 0
    255
    10
    11259375
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

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

    Причина

    Исходный код использует ту же запись, что и стандартный шестнадцатеричный вывод.

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

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

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

    Проблема

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

    Решение

    • У Duration есть сложение, вычитание, умножение на целое в любом порядке, сравнение, вывод и toMillis(). Вывод имеет форму 1500ms, а из целого длительность получается через 1ms * n.
    • Переполнение, отрицательный результат, отрицательный множитель и переполнение toMillis() вызывают TPZ4004 при выполнении.
    • В Топазе 6.0 у Duration нет преобразования в JSON.

    Примеры

    Add and subtract Duration values

    example.tpzAdd and subtract Duration values
    1. import std.io { writeLine }
    2. let sum = 1s + 500ms
    3. let difference = 2s - 500ms
    4. writeLine("{sum}")
    5. writeLine("{difference}")
    Ожидаемый выводКод завершения 0
    1500ms
    1500ms
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Multiply a Duration by an int in either order

    example.tpzMultiply a Duration by an int in either order
    1. import std.io { writeLine }
    2. let count = 3
    3. let left = 500ms * count
    4. let right = count * 500ms
    5. let constructed = 1ms * count
    6. writeLine("{left}")
    7. writeLine("{right}")
    8. writeLine("{constructed}")
    Ожидаемый выводКод завершения 0
    1500ms
    1500ms
    3ms
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Compare Duration values by milliseconds

    example.tpzCompare Duration values by milliseconds
    1. import std.io { writeLine }
    2. let first = 1s
    3. let same = 1000ms
    4. let later = 2s
    5. writeLine("{Eq.equals(first, same)}")
    6. writeLine("{Order.compare(first, later) < 0}")
    7. writeLine("{first == same}")
    8. writeLine("{first != later}")
    9. writeLine("{first < later}")
    10. writeLine("{first <= same}")
    11. writeLine("{later > first}")
    12. writeLine("{same >= first}")
    Ожидаемый выводКод завершения 0
    true
    true
    true
    true
    true
    true
    true
    true
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Display millisecond literals and extract int milliseconds

    example.tpzDisplay millisecond literals and extract int milliseconds
    1. import std.io { writeLine }
    2. let delay = 1500ms
    3. let minute = 1m
    4. let second = 1s
    5. let zero = 0ms
    6. let endpoint = 18446744073709551615ms
    7. let intEndpoint = 9223372036854775807ms
    8. writeLine(Show.show(delay))
    9. writeLine("{delay.toMillis()}")
    10. writeLine("{minute.toMillis()}")
    11. writeLine("{second.toMillis()}")
    12. writeLine("{zero}")
    13. writeLine("{endpoint}")
    14. writeLine("{intEndpoint.toMillis()}")
    Ожидаемый выводКод завершения 0
    1500ms
    1500
    60000
    1000
    0ms
    18446744073709551615ms
    9223372036854775807
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. 1500ms
    2. 1500
    3. 60000
    4. 1000
    5. 0ms
    6. 18446744073709551615ms
    7. 9223372036854775807

    Reject a Duration subtraction below zero

    example.tpzReject a Duration subtraction below zero
    1. let earlier = 1ms
    2. let later = 2ms
    3. let difference = earlier - later
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    • TPZ4004 →

      duration-negative-difference at example.tpz:3:18

    Reject a millisecond count outside int

    example.tpzReject a millisecond count outside int
    1. let delay = 9223372036854775808ms
    2. let count = delay.toMillis()
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    • TPZ4004 →

      duration-to-millis-overflow at example.tpz:2:13

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

    • Добавить отдельную функцию преобразования целого. Функция и умножение будут создавать одну и ту же длительность.
    • Ввести отдельный тип для каждой единицы. Единица уже одна, миллисекунды, поэтому согласование единиц не нужно.
    • Добавить деление. Длительность строится только из литерала и умножения, и операции не пересекаются.
    • Показывать в укрупнённых единицах, например 1s500ms. Длительность показывается в миллисекундах, чтобы форма записи была одна.

    Причина

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

    Изменённые правила Duration values and operations →

    Решённые открытые вопросы Duration operations beyond timeout admission →

    У всех тегов шаблонов одинаковое экранирование

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

    Проблема

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

    Решение

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

    Примеры

    Unknown escape in a r template

    example.tpzUnknown escape in a r templateОткрыть песочницу →
    1. let value = r"\d"
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Every tag cooks the same single-line escapes

    example.tpzEvery tag cooks the same single-line escapesОткрыть песочницу →
    1. import std.io
    2. let pattern = r"\n\r\t\\\"\{\}"
    3. io.writeLine(pattern.parts[0])
    4. let command = sh"\n\r\t\\\"\{\}"
    5. io.writeLine(command.parts[0])
    6. let query = sql"\n\r\t\\\"\{\}"
    7. io.writeLine(query.parts[0])
    Ожидаемый выводКод завершения 0
    
    
    	\"{}
    
    
    	\"{}
    
    
    	\"{}
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. \"{}
    2. \"{}
    3. \"{}

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

    • Оставить необработанную обратную косую черту и отдельные разделители для r. Для регулярных выражений понадобятся особые правила для обратной косой черты и скобок.

    Причина

    Экранирование на уровне исходного текста одинаково для каждого тега.

    Изменённые правила String escape values →Tagged-template construction and display →

    Решённые открытые вопросы Tagged-template value contract →

    Формат конца строки в исходнике сохраняет значение литерала

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

    Проблема

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

    Решение

    • Реальные LF, CRLF и одиночный CR внутри строкового литерала читаются как один перевод строки.
    • Чтобы включить CR в данные строки, используйте экранирование. Отступы обрабатываются одинаково при любом формате конца строки.

    Примеры

    Physical CR uses the same multiline text and indentation

    example.tpzPhysical CR uses the same multiline text and indentationОткрыть песочницу →
    1. import std.io
    2. let value = """ first second """
    3. io.writeLine(value.encodeUtf8().toHex())
    Ожидаемый выводКод завершения 0
    66697273740a7365636f6e640a
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Escaped carriage returns remain character data

    example.tpzEscaped carriage returns remain character dataОткрыть песочницу →
    1. import std.io
    2. let opening = """\rhead"""
    3. let single = "S\rE"
    4. let multi = """
    5. M\rN
    6. """
    7. io.writeLine(opening.encodeUtf8().toHex())
    8. io.writeLine(single.encodeUtf8().toHex())
    9. io.writeLine(multi.encodeUtf8().toHex())
    Ожидаемый выводКод завершения 0
    0d68656164
    530d45
    4d0d4e0a
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. 0d68656164
    2. 530d45
    3. 4d0d4e0a

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

    • Учитывать одинаково только LF и CRLF. Исходник с концами строк CR мог бы получить другое строковое значение.

    Причина

    Смена настройки редактора сохраняет строковые значения.

    Изменённые правила Multiline newline values →Multiline closing indentation →

    Path.from создаёт путь из строки

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

    Проблема

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

    Решение

    Тег p удалён. Чтобы создать путь из текста, вызовите Path.from.

    Примеры

    Path construction uses Path.from instead of the p tag

    example.tpzPath construction uses Path.from instead of the p tagОткрыть песочницу →
    1. let value = p"notes"
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Path.from normalizes literal and interpolated text

    example.tpzPath.from normalizes literal and interpolated textОткрыть песочницу →
    1. import std.io
    2. import std.path { Path }
    3. function normalized(text: string) -> string {
    4. match (Path.from(text)) {
    5. case Ok(value) => value.toString()
    6. case Err(error) => error
    7. }
    8. }
    9. let directory = "notes"
    10. io.writeLine(normalized("./{directory}//draft/../chapter.tpz"))
    11. io.writeLine(normalized("notes\\draft\\..\\chapter.tpz"))
    12. io.writeLine(normalized("notes/.."))
    13. io.writeLine(normalized("Notes/가.TPZ"))
    Ожидаемый выводКод завершения 0
    notes/chapter.tpz
    notes/chapter.tpz
    .
    Notes/가.TPZ
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. notes/chapter.tpz
    2. notes/chapter.tpz
    3. .
    4. Notes/가.TPZ

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

    • Задать тегу p новые правила создания пути. Для создания пути появится вторая запись с отдельным правилом.
    • Оставить тег p как есть. У создания пути должен быть один способ.

    Причина

    В любом месте кода создание пути видно по одному и тому же имени. Path.join безопасно соединяет части пути, а Path.from читает строку как путь.

    Изменённые правила Registered template tags →Construct a normalized Path with Path.from →

    Строка исходника из одних пробелов становится пустой строкой

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

    Проблема

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

    Решение

    • Удаляйте пробелы и табуляцию в строках исходника, где есть только эти символы. Перевод строки сохраняется.
    • Данные из экранирования и интерполяции сохраняются.

    Примеры

    Blank source lines ignore indentation

    example.tpzBlank source lines ignore indentationОткрыть песочницу →
    1. import std.io
    2. let indented = """
    3. A
    4. B
    5. """
    6. let unindented = """A
    7. B"""
    8. let tagged = r"""
    9. A
    10. B
    11. """
    12. io.writeLine(indented.encodeUtf8().toHex())
    13. io.writeLine(unindented.encodeUtf8().toHex())
    14. io.writeLine(tagged.parts[0].encodeUtf8().toHex())
    Ожидаемый выводКод завершения 0
    410a0a0a420a
    410a0a42
    410a0a420a
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. 410a0a0a420a
    2. 410a0a42
    3. 410a0a420a

    Escaped and inserted whitespace remains data

    example.tpzEscaped and inserted whitespace remains dataОткрыть песочницу →
    1. import std.io
    2. let inserted = " \t"
    3. let value = """
    4. A
    5. \t
    6. {inserted}
    7. B
    8. """
    9. io.writeLine(value.encodeUtf8().toHex())
    Ожидаемый выводКод завершения 0
    410a090a20090a420a
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

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

    Причина

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

    Изменённые правила Whitespace and interpolation in multiline strings →

    Интерполяция строк и производный Show записывают конечные числа без экспоненты

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

    Проблема

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

    Решение

    • При интерполяции строк и в производном Show для конечного ненулевого числа выбирается десятичная запись с наименьшим числом значащих цифр, которая округляется в то же значение binary64.
    • Из таких записей выбирается ближайшая к точному значению. При равном расстоянии последняя цифра должна быть чётной.
    • Запись разворачивается без экспоненты, после точки остаётся хотя бы одна цифра.
    • Формы 0.0, -0.0, inf, -inf и NaN сохраняются. Знак и полезная нагрузка NaN не выводятся.

    Примеры

    Finite floats use positional text with a decimal point

    example.tpzFinite floats use positional text with a decimal point
    1. import std.io { writeLine }
    2. let large = 1000000000000000.0
    3. let larger = 1000000000000000000000.0
    4. let small = 0.0000001
    5. let sum = 0.1 + 0.2
    6. let shortSignificand = 1000000000000000128.0
    7. writeLine("{large}")
    8. writeLine("{larger}")
    9. writeLine("{small}")
    10. writeLine("{sum}")
    11. writeLine("{shortSignificand}")
    Ожидаемый выводКод завершения 0
    1000000000000000.0
    1000000000000000000000.0
    0.0000001
    0.30000000000000004
    1000000000000000100.0
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. 1000000000000000.0
    2. 1000000000000000000000.0
    3. 0.0000001
    4. 0.30000000000000004
    5. 1000000000000000100.0

    Render the largest finite float and the smallest normal and subnormal

    example.tpzRender the largest finite float and the smallest normal and subnormal
    1. import std.io { writeLine }
    2. let largest = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0
    3. let smallestNormal = 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201383090232717332404064219215980462331830553327416887204434813918195854283159012511020564067339731035811005152434161553460108856012385377718821130777993532002330479610147442583636071921565046942503734208375250806650616658158948720491179968591639648500635908770118304874799780887753749949451580451605050915399856582470818645113537935804992115981085766051992433352114352390148795699609591288891602992641511063466313393663477586513029371762047325631781485664350872122828637642044846811407613911477062801689853244110024161447421618567166150540154285084716752901903161322778896729707373123334086988983175067838846926092773977972858659654941091369095406136467568702398678315290680984617210924625396728515625
    4. let smallestSubnormal = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625
    5. writeLine("{largest}")
    6. writeLine("{smallestNormal}")
    7. writeLine("{smallestSubnormal}")
    Ожидаемый выводКод завершения 0
    179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0
    0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014
    0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Negative underflow retains zero sign while NaN drops its sign

    example.tpzNegative underflow retains zero sign while NaN drops its signОткрыть песочницу →
    1. import std.io { writeLine }
    2. let negativeTiny = -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
    3. let nan = 0.0 / 0.0
    4. let negativeNan = -nan
    5. writeLine("{0.0}|{-0.0}|{negativeTiny}")
    6. writeLine("{nan}|{negativeNan}")
    7. writeLine("{1.0 / 0.0}|{-1.0 / 0.0}")
    Ожидаемый выводКод завершения 0
    0.0|-0.0|-0.0
    NaN|NaN
    inf|-inf
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Derived Show renders record fields and Set elements with the same float rule

    example.tpzDerived Show renders record fields and Set elements with the same float rule
    1. import std.test { assertContains }
    2. record Reading derives Show {
    3. value: float,
    4. samples: Set<float>,
    5. }
    6. let sample = Reading {
    7. value: 1000000000000000.0,
    8. samples: set { 1000000000000000000000.0, 0.0000001 },
    9. }
    10. let text = Show.show(sample)
    11. assertContains(text, "1000000000000000.0")
    12. assertContains(text, "1000000000000000000000.0")
    13. assertContains(text, "0.0000001")
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    • Убирать .0 у больших целых по значению чисел. После произвольной границы их запись станет неотличимой от целочисленной.
    • Использовать экспоненту для больших и малых значений. Такую запись нельзя вставить в исходник как конечный литерал.

    Причина

    Выведенное конечное число можно вставить в исходник с тем же значением и отличить от целого.

    Изменённые правила Decimal float values and text rendering →

    Path.from служит единственным конструктором пути

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

    Проблема

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

    Решение

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

    Примеры

    Path.from normalizes literal and interpolated text →

    Use an existing Path directly

    example.tpzUse an existing Path directlyОткрыть песочницу →
    1. import std.path { Path }
    2. function keep(value: Path) -> Path { value }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

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

    • Сохранить прежние конструкторы и normalize. Одна операция по-прежнему будет иметь несколько имён.

    Причина

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

    Изменённые правила Construct a normalized Path with Path.from →