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

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

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

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

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

    Загрузка →

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

    Структуры

    Режимы десятичного округления образуют обычное перечисление

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

    Проблема

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

    Решение

    • RoundingMode является обычным перечислением из шести вариантов. Значение пишется как RoundingMode.HalfEven(), шаблон как case HalfEven().
    • Полнота, равенство, вывод и ключи подчиняются правилам обычного перечисления.

    Примеры

    Six constructor patterns exhaust RoundingMode

    example.tpzSix constructor patterns exhaust RoundingMode
    1. import std.decimal { RoundingMode }
    2. import std.io { writeLine }
    3. function describe(mode: RoundingMode) -> string {
    4. match (mode) {
    5. case HalfEven() => "half even"
    6. case HalfUp() => "half up"
    7. case TowardZero() => "toward zero"
    8. case AwayFromZero() => "away from zero"
    9. case Down() => "down"
    10. case Up() => "up"
    11. }
    12. }
    13. for mode in ([RoundingMode.HalfEven(), RoundingMode.HalfUp(), RoundingMode.TowardZero(), RoundingMode.AwayFromZero(), RoundingMode.Down(), RoundingMode.Up()]) {
    14. writeLine(describe(mode))
    15. }
    Ожидаемый выводКод завершения 0
    half even
    half up
    toward zero
    away from zero
    down
    up
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. half even
    2. half up
    3. toward zero
    4. away from zero
    5. down
    6. up

    Omitting one RoundingMode variant is not exhaustive

    example.tpzOmitting one RoundingMode variant is not exhaustive
    1. import std.decimal { RoundingMode }
    2. function describe(mode: RoundingMode) -> string {
    3. match (mode) {
    4. case HalfEven() => "half even"
    5. case HalfUp() => "half up"
    6. case TowardZero() => "toward zero"
    7. case AwayFromZero() => "away from zero"
    8. case Down() => "down"
    9. }
    10. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    RoundingMode values are Map keys and Set elements

    example.tpzRoundingMode values are Map keys and Set elements
    1. let modes: Map<RoundingMode, int> = map { RoundingMode.HalfEven(): 1 }
    2. let selected: Set<RoundingMode> = set { RoundingMode.HalfEven(), RoundingMode.Up() }
    Ожидаемый выводКод завершения 0
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    A bare HalfEven binder collides with the enum constructor

    example.tpzA bare HalfEven binder collides with the enum constructor
    1. function describe(mode: RoundingMode) -> int {
    2. match (mode) {
    3. case HalfEven => 1
    4. }
    5. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    • TPZ5712 →

      pattern-constructor-binding-collision at example.tpz:3:10

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

    • Сохранить специальный тип и добавить лишь шаблоны конструкторов. Шаблоны заработают, но у ключей и других операций останутся особые правила.
    • Запретить образцы и разрешить только ==. Исчерпывающий match отклонялся бы, а конструкторов стало бы два вида.

    Причина

    Режимы работают как другие варианты без данных.

    Изменённые правила Variants without payloads →Every match is exhaustive →

    Данные варианта могут иметь тип объединения с перечислением

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

    Проблема

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

    Решение

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

    Примеры

    Construct and match both union payload alternatives

    example.tpzConstruct and match both union payload alternatives
    1. import std.io { writeLine }
    2. enum Inner { Leaf }
    3. enum Outer { Wrapped(Inner | int) }
    4. function describe(value: Outer) -> string {
    5. match (value) {
    6. case Wrapped(payload) => match (payload) {
    7. case number: int => "{number}"
    8. case _ => "leaf"
    9. }
    10. }
    11. }
    12. writeLine(describe(Outer.Wrapped(Inner.Leaf())))
    13. writeLine(describe(Outer.Wrapped(7)))
    Ожидаемый выводКод завершения 0
    leaf
    7
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

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

    Причина

    Объявленную комбинацию типов можно использовать непосредственно.

    Изменённые правила Variants with payloads →Enum declarations and payload types →

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

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

    Проблема

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

    Решение

    • В вариантах перечислений допустимы None, Some, Ok и Err. Вариант определяется объявляющим номинальным типом.
    • Если объединение делает имя неоднозначным, сузьте его обычным шаблоном типа.

    Примеры

    Enum variants and prelude constructors retain separate identities

    example.tpzEnum variants and prelude constructors retain separate identities
    1. import std.io { writeLine }
    2. enum Reply { None, Some(int), Ok(string), Err(bool) }
    3. function describe(value: Reply) -> string {
    4. match (value) {
    5. case None() => "enum none"
    6. case Some(number) => "enum some {number}"
    7. case Ok(text) => "enum ok {text}"
    8. case Err(flag) => if (flag) { "enum error" } else { "enum false" }
    9. }
    10. }
    11. function option(value: Option<int>) -> string {
    12. match (value) {
    13. case None() => "option none"
    14. case Some(number) => "option some {number}"
    15. }
    16. }
    17. function result(value: Result<int, string>) -> string {
    18. match (value) {
    19. case Ok(number) => "result ok {number}"
    20. case Err(text) => "result error {text}"
    21. }
    22. }
    23. writeLine(describe(Reply.None()))
    24. writeLine(describe(Reply.Some(4)))
    25. writeLine(describe(Reply.Ok("yes")))
    26. writeLine(describe(Reply.Err(true)))
    27. writeLine(option(None()))
    28. writeLine(option(Some(5)))
    29. writeLine(result(Ok(6)))
    30. writeLine(result(Err("no")))
    Ожидаемый выводКод завершения 0
    enum none
    enum some 4
    enum ok yes
    enum error
    option none
    option some 5
    result ok 6
    result error no
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. enum none
    2. enum some 4
    3. enum ok yes
    4. enum error
    5. option none
    6. option some 5
    7. result ok 6
    8. result error no

    Typed narrowing distinguishes an enum Ok from a Result Ok

    example.tpzTyped narrowing distinguishes an enum Ok from a Result Ok
    1. import std.io { writeLine }
    2. enum Reply { Ok(int) }
    3. function describe(value: Reply | Result<int, string>) -> string {
    4. match (value) {
    5. case reply: Reply => match (reply) { case Ok(number) => "reply {number}" }
    6. case result: Result<int, string> => match (result) {
    7. case Ok(number) => "result {number}"
    8. case Err(text) => text
    9. }
    10. }
    11. }
    12. let result: Result<int, string> = Ok(8)
    13. writeLine(describe(Reply.Ok(7)))
    14. writeLine(describe(result))
    Ожидаемый выводКод завершения 0
    reply 7
    result 8
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Reject a shared bare constructor head before inspecting its payload

    example.tpzReject a shared bare constructor head before inspecting its payload
    1. enum Left { Shared(int) }
    2. enum Right { Shared(int) }
    3. function describe(value: Left | Right) -> int {
    4. match (value) {
    5. case Shared(number) => number
    6. case _ => 0
    7. }
    8. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    • TPZ5001 →

      structures-ambiguous-constructor-pattern at example.tpz:5:10

    A qualified enum None uses its declared payload

    example.tpzA qualified enum None uses its declared payload
    1. import std.io { writeLine }
    2. enum Reply { None(int) }
    3. let reply = Reply.None(7)
    4. writeLine(match (reply) { case None(value) => "{value}" })
    Ожидаемый выводКод завершения 0
    7
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

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

    Причина

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

    Изменённые правила Variant names and prelude constructors →

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

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

    Проблема

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

    Решение

    Повтор имени поля в одном структурном обновлении отклоняется.

    Примеры

    A structural update cannot repeat a field

    example.tpzA structural update cannot repeat a field
    1. let point = { x: 1 }
    2. let moved = point {
    3. x: 2,
    4. x: 3,
    5. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    • TPZ5008 →

      duplicate-record-field-initializer at example.tpz:4:3

    One explicit initializer can replace a copied field

    example.tpzOne explicit initializer can replace a copied fieldОткрыть песочницу →
    1. import std.io
    2. record Point { x: int }
    3. let original = { x: 1 }
    4. let updated = original { x: 2 }
    5. let named = Point { x: 3 }
    6. let copied = Point { ...named, x: 4 }
    7. io.writeLine("{updated.x}:{original.x}:{copied.x}:{named.x}")
    Ожидаемый выводКод завершения 0
    2:1:4:3
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

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

    Причина

    Для каждого поля указано одно новое значение.

    Изменённые правила Repeated structural update fields →

    Конструктору нужен список аргументов и в позиции значения

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

    Проблема

    Имя конструктора в роли функции могло пройти проверку и дать ошибку позднее. У разных конструкторов одна запись вызывала разные сообщения.

    Решение

    • В позиции значения пишите Name(arguments). Отсутствие списка вызывает TPZ5004 при проверке. Отдельное None выдаёт TPZ2012 при разборе по правилу зарезервированного имени.
    • Для передачи операции создания вызовите конструктор с аргументами внутри лямбды.

    Примеры

    Bare payload variant is rejected

    example.tpzBare payload variant is rejectedОткрыть песочницу →
    1. enum Choice { Full(int), Empty }
    2. let make = Choice.Full
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Bare empty variant is rejected

    example.tpzBare empty variant is rejected
    1. enum Choice { Full(int), Empty }
    2. let value = Choice.Empty
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Bare Some is rejected

    example.tpzBare Some is rejected
    1. let make = Some
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Bare Ok is rejected

    example.tpzBare Ok is rejected
    1. let make = Ok
    Ожидаемый выводНенулевой код завершения
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Empty variant uses parentheses

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

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

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

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

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

    Причина

    В коде видно, где создаётся значение и где сохраняется функция для будущего вызова.

    Изменённые правила Bare constructor references →Bare None in value position →Constructors in function values →

    Self обозначает тип, реализующий протокол

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

    Проблема

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

    Решение

    Собственных параметров типа у объявления протокола нет. Реализующий тип обозначается Self.

    Примеры

    Reject an explicit protocol receiver binder

    example.tpzReject an explicit protocol receiver binder
    1. protocol Labelled<T> {
    2. function label(value: T) -> string
    3. }
    4. record Item { name: string }
    5. impl Labelled<Item> {
    6. function label(value: Item) -> string { value.name }
    7. }
    8. let text: string = Labelled.label(Item { name: "Moss" })
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    • TPZ2001 →

      protocol-explicit-receiver-binder at example.tpz:1:18

    Use Self for the conforming type

    example.tpzUse Self for the conforming typeОткрыть песочницу →
    1. protocol Labelled {
    2. function label(value: Self) -> string
    3. }
    4. record Item { name: string }
    5. impl Labelled<Item> {
    6. function label(value: Item) -> string { value.name }
    7. }
    8. let text: string = Labelled.label(Item { name: "Moss" })
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

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

    • Задавать псевдоним получателя через protocol P<T>. Одна роль называлась бы по-разному в разных протоколах.

    Причина

    Реализующий тип узнаётся по одной записи.

    Изменённые правила Protocol declarations use Self →

    Сигнатуры протокола следуют правилам обычных функций

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

    Проблема

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

    Решение

    • Действуют обычные правила обобщённых, переменных и необязательных параметров. Первый параметр-значение не обязан быть Self.
    • У сигнатуры без тела указывается возвращаемый тип.

    Примеры

    Implementation binders and renamed method binders remain distinct

    example.tpzImplementation binders and renamed method binders remain distinct
    1. import std.io { writeLine }
    2. protocol Echo {
    3. function echo<U: Show>(value: Self, item: U) -> U
    4. }
    5. record Box<T> { value: T }
    6. impl<T> Echo<Box<T>> {
    7. function echo<V: Show>(value: Box<T>, item: V) { item }
    8. }
    9. let box: Box<int> = Box { value: 3 }
    10. writeLine(Echo.echo<Box<int>, string>(box, "ok"))
    11. let inferred: int = Echo.echo(box, 9)
    12. writeLine("{inferred}")
    Ожидаемый выводКод завершения 0
    ok
    9
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Protocol defaults and a variadic implementation share one call plan

    example.tpzProtocol defaults and a variadic implementation share one call plan
    1. import std.io { writeLine }
    2. protocol Sum {
    3. function sum(value: Self, start: int = 10, ...items: int) -> int
    4. }
    5. record Item { offset: int }
    6. impl Sum<Item> {
    7. function sum(value: Item, start: int, ...items: int) {
    8. let mut total = value.offset + start
    9. for item in (items) { total = total + item }
    10. total
    11. }
    12. }
    13. let item = Item { offset: 1 }
    14. writeLine("{Sum.sum(item)}")
    15. writeLine("{Sum.sum(item, 2, ...[3, 4], 5)}")
    16. writeLine("{Sum.sum(item, ...[2, 3])}")
    Ожидаемый выводКод завершения 0
    11
    15
    16
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    An omitted implementation result uses the protocol result context

    example.tpzAn omitted implementation result uses the protocol result context
    1. protocol Choose {
    2. function choose(value: Self) -> int | string
    3. }
    4. record Item {}
    5. impl Choose<Item> {
    6. function choose(value: Item) { 7 }
    7. }
    8. let chosen: int | string = Choose.choose(Item {})
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

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

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

    Причина

    Правила обычной функции применимы и к протокольной сигнатуре.

    Изменённые правила Matching the protocol signature →Protocol bodies →

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

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

    Проблема

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

    Решение

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

    Примеры

    Implementation binders and renamed method binders remain distinct →

    Protocol defaults and a variadic implementation share one call plan →

    An omitted implementation result uses the protocol result context →

    Conformance visibility makes a separate method export invalid

    example.tpzConformance visibility makes a separate method export invalidОткрыть песочницу →
    1. protocol Labelled {
    2. function label(value: Self) -> string
    3. }
    4. record Item {}
    5. impl Labelled<Item> {
    6. export function label(value: Item) -> string { "item" }
    7. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    An implementation cannot introduce its own omitted argument

    example.tpzAn implementation cannot introduce its own omitted argumentОткрыть песочницу →
    1. protocol Labelled {
    2. function label(value: Self, suffix: string) -> string
    3. }
    4. record Item {}
    5. impl Labelled<Item> {
    6. function label(value: Item, suffix: string = "!") -> string { suffix }
    7. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    A conditional derive and a manual specialization share the overlap check

    example.tpzA conditional derive and a manual specialization share the overlap check
    1. record Box<T> derives<T: Eq> Eq<Box<T>> { value: T }
    2. impl Eq<Box<int>> {
    3. function equals(a: Box<int>, b: Box<int>) -> bool { a.value == b.value }
    4. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    • TPZ5521 →

      duplicate-protocol-conformance at example.tpz:1:30

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

    • Задать отдельные функции реализации и приоритет между ними. Значения и видимость придётся проверять снова, а порядок повлияет на выбор реализации.
    • Сохранить нынешнее ограничение методов реализации. У значений по умолчанию и видимости должен быть один владелец.

    Причина

    Контракт задаёт значения при вызове, а реализация выбирается однозначно.

    Изменённые правила Implementation methods use ordinary functions →One conformance across the dependency graph →

    Видимость импортированной реализации не зависит от способа объявления

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

    Проблема

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

    Решение

    У явных и выведенных реализаций одинаковая видимость при импорте. Явный метод вызывается из модуля определения.

    Примеры

    A manual conformance is visible through a nominal import

    example.tpzA manual conformance is visible through a nominal import
    1. import remote { Item as RemoteItem }
    2. let imported = RemoteItem { n: 1 }
    3. let same = Eq.equals(imported, imported)
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    remote.tpzA manual conformance is visible through a nominal import
    1. export record Item { n: int }
    2. impl Eq<Item> {
    3. function equals(a: Item, b: Item) -> bool { a.n == b.n }
    4. }
    Ожидаемый результат

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

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

    A derived conformance is visible through a nominal import

    example.tpzA derived conformance is visible through a nominal import
    1. import remote { Item as RemoteItem }
    2. let imported = RemoteItem { n: 1 }
    3. let same = Eq.equals(imported, imported)
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    remote.tpzA derived conformance is visible through a nominal import
    1. export record Item derives Eq { n: int }
    Ожидаемый результат

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

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

    An imported protocol call executes its manual method

    example.tpzAn imported protocol call executes its manual method
    1. import std.io { writeLine }
    2. import remote { Item as RemoteItem }
    3. let left = RemoteItem { n: 1 }
    4. let right = RemoteItem { n: 11 }
    5. writeLine("{Eq.equals(left, right)}")
    Ожидаемый выводКод завершения 0
    true
    
    $ topaz run example.tpz --language-version 6.0
    remote.tpzAn imported protocol call executes its manual method
    1. export record Item { n: int }
    2. impl Eq<Item> {
    3. function equals(a: Item, b: Item) -> bool { a.n % 10 == b.n % 10 }
    4. }
    Ожидаемый результат

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

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

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

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

    • Для двух видов реализации задать разную видимость. Смена способа объявления изменила бы импортирующий код.

    Причина

    Импортирующий код читает одно правило видимости.

    Изменённые правила Conformance across modules →

    Ручная реализация JSON использует encode и decode

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

    Проблема

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

    Решение

    • При ручной реализации объявляются обычные методы encode и decode.
    • Дерево декодируется вызовом JSON.decode<T>(tree). Метод JSONValue.decode<T>() удалён.

    Примеры

    A manual JSON implementation supplies both conversions

    example.tpzA manual JSON implementation supplies both conversions
    1. import std.json { JSONValue }
    2. record Token { text: string }
    3. impl JSON<Token> {
    4. function encode(value: Token) -> Result<JSONValue, string> {
    5. JSON.encode(value.text)
    6. }
    7. function decode(value: JSONValue) -> Result<Token, string> {
    8. match (value.asString()) {
    9. case Some(text) => Ok(Token { text: text })
    10. case None() => Err("expected token string")
    11. }
    12. }
    13. }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Text and tree conversion use the same manual JSON implementation

    example.tpzText and tree conversion use the same manual JSON implementation
    1. import std.io { writeLine }
    2. import std.json { JSONValue, parse, parseAs, stringify }
    3. record Token { text: string }
    4. impl JSON<Token> {
    5. function encode(value: Token) -> Result<JSONValue, string> {
    6. JSON.encode(value.text)
    7. }
    8. function decode(value: JSONValue) -> Result<Token, string> {
    9. match (value.asString()) {
    10. case Some(text) => Ok(Token { text: text })
    11. case None() => Err("expected token string")
    12. }
    13. }
    14. }
    15. writeLine(match (stringify(Token { text: "paper" })) {
    16. case Ok(text) => text
    17. case Err(message) => message
    18. })
    19. writeLine(match (parseAs<Token>("\"paper\"")) {
    20. case Ok(value) => value.text
    21. case Err(message) => message
    22. })
    23. writeLine(match (parseAs<Token>("17")) {
    24. case Ok(value) => value.text
    25. case Err(message) => message
    26. })
    27. writeLine(match (parse("\"ink\"")) {
    28. case Ok(tree) => match (JSON.decode<Token>(tree)) {
    29. case Ok(value) => value.text
    30. case Err(message) => message
    31. }
    32. case Err(_) => "parse failed"
    33. })
    Ожидаемый выводКод завершения 0
    "paper"
    paper
    expected token string
    ink
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. "paper"
    2. paper
    3. expected token string
    4. ink

    An empty JSON marker omits the required conversion methods

    example.tpzAn empty JSON marker omits the required conversion methodsОткрыть песочницу →
    1. record Token { text: string }
    2. impl JSON<Token> {}
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    JSONValue decoding uses the ordinary protocol call

    example.tpzJSONValue decoding uses the ordinary protocol call
    1. import std.json { JSONValue }
    2. function read(tree: JSONValue) -> Result<int, string> {
    3. tree.decode<int>()
    4. }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Decode a JSONValue with one protocol-qualified form

    example.tpzDecode a JSONValue with one protocol-qualified form
    1. import std.json { JSONValue }
    2. function read(tree: JSONValue) -> Result<int, string> {
    3. JSON.decode<int>(tree)
    4. }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

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

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

    Причина

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

    Изменённые правила JSON conformance →

    Using закрывает ресурс при обычном и структурированном досрочном выходе

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

    Проблема

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

    Решение

    • Очистка using выполняется при обычном и структурированном досрочном выходе.
    • Очистка при обычной ошибке выполнения и повторный close выходят за пределы общей для всех хостов гарантии.

    Примеры

    Acquire once, run body defers, then close

    example.tpzAcquire once, run body defers, then close
    1. import std.io
    2. let mut acquisitions = 0
    3. let mut later: () -> string = () => "unset"
    4. function acquire() -> Result<File, string> {
    5. acquisitions += 1
    6. io.open("input.txt")
    7. }
    8. function scenario() -> Result<int, string> {
    9. using file = (acquire()?) {
    10. later = () => match (file.read()) {
    11. case Ok(text) => text
    12. case Err(e) => e
    13. }
    14. defer { io.writeLine(match (file.read()) {
    15. case Ok(text) => "defer:{text}"
    16. case Err(e) => "defer:{e}"
    17. }) }
    18. io.writeLine("body")
    19. 99
    20. }
    21. Ok(7)
    22. }
    23. let ignored = scenario()
    24. io.writeLine("acquisitions:{acquisitions}")
    25. io.writeLine(later())
    Ожидаемый выводКод завершения 0
    body
    defer:payload
    acquisitions:1
    file is closed
    
    $ topaz run example.tpz · Целевой продукт 5.21.3
    input.txtAcquire once, run body defers, then close
    1. payload
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. body
    2. defer:payload
    3. acquisitions:1
    4. file is closed

    Close on return, propagation, break, and continue

    example.tpzClose on return, propagation, break, and continue
    1. import std.io
    2. let mut later: () -> string = () => "unset"
    3. function fail() -> Result<int, string> { Err("stop") }
    4. function onReturn() -> Result<int, string> {
    5. using file = (io.open("input.txt")?) {
    6. later = () => match (file.read()) {
    7. case Ok(text) => text
    8. case Err(e) => e
    9. }
    10. return Ok(7)
    11. }
    12. Ok(0)
    13. }
    14. let ignoredonReturn = onReturn()
    15. io.writeLine("onReturn:{later()}")
    16. function onQuestion() -> Result<int, string> {
    17. using file = (io.open("input.txt")?) {
    18. later = () => match (file.read()) {
    19. case Ok(text) => text
    20. case Err(e) => e
    21. }
    22. fail()?
    23. }
    24. Ok(0)
    25. }
    26. let ignoredonQuestion = onQuestion()
    27. io.writeLine("onQuestion:{later()}")
    28. function onBreak() -> Result<int, string> {
    29. let mut i = 0
    30. while (i < 1) {
    31. using file = (io.open("input.txt")?) {
    32. later = () => match (file.read()) {
    33. case Ok(text) => text
    34. case Err(e) => e
    35. }
    36. break
    37. }
    38. }
    39. Ok(0)
    40. }
    41. let ignoredonBreak = onBreak()
    42. io.writeLine("onBreak:{later()}")
    43. function onContinue() -> Result<int, string> {
    44. let mut i = 0
    45. while (i < 1) {
    46. using file = (io.open("input.txt")?) {
    47. later = () => match (file.read()) {
    48. case Ok(text) => text
    49. case Err(e) => e
    50. }
    51. i += 1
    52. continue
    53. }
    54. }
    55. Ok(0)
    56. }
    57. let ignoredonContinue = onContinue()
    58. io.writeLine("onContinue:{later()}")
    Ожидаемый выводКод завершения 0
    onReturn:file is closed
    onQuestion:file is closed
    onBreak:file is closed
    onContinue:file is closed
    
    $ topaz run example.tpz · Целевой продукт 5.21.3
    input.txtClose on return, propagation, break, and continue
    1. payload
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. onReturn:file is closed
    2. onQuestion:file is closed
    3. onBreak:file is closed
    4. onContinue:file is closed

    Evaluate the return value, then close nested resources

    example.tpzEvaluate the return value, then close nested resources
    1. import std.io
    2. let mut outerClosed: () -> bool = () => false
    3. let mut innerClosed: () -> bool = () => false
    4. function isClosed(file: File) -> bool {
    5. match (file.read()) {
    6. case Ok(text) => false
    7. case Err(error) => true
    8. }
    9. }
    10. function makeResult() -> Result<int, string> {
    11. io.writeLine("return-value")
    12. Ok(7)
    13. }
    14. function scenario() -> Result<int, string> {
    15. using outer = (io.open("input.txt")?) {
    16. outerClosed = () => isClosed(outer)
    17. defer { io.writeLine("outer-defer:inner-closed={innerClosed()}") }
    18. using inner = (io.open("input.txt")?) {
    19. innerClosed = () => isClosed(inner)
    20. defer { io.writeLine("inner-defer") }
    21. return makeResult()
    22. }
    23. }
    24. Ok(0)
    25. }
    26. let outcome = scenario()
    27. io.writeLine(match (outcome) {
    28. case Ok(value) => "result:{value}"
    29. case Err(error) => "open:{error}"
    30. })
    31. io.writeLine("outer-closed:{outerClosed()}")
    32. io.writeLine("inner-closed:{innerClosed()}")
    Ожидаемый выводКод завершения 0
    return-value
    inner-defer
    outer-defer:inner-closed=true
    result:7
    outer-closed:true
    inner-closed:true
    
    $ topaz run example.tpz · Целевой продукт 5.21.3
    input.txtEvaluate the return value, then close nested resources
    1. payload
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. return-value
    2. inner-defer
    3. outer-defer:inner-closed=true
    4. result:7
    5. outer-closed:true
    6. inner-closed:true

    The native File read result makes closing observable. The outer body defer sees the inner resource closed before the outer resource closes.

    An ordinary fault skips remaining cleanup

    example.tpzAn ordinary fault skips remaining cleanup
    1. import std.io
    2. function divide(divisor: int) -> int {
    3. 42 / divisor
    4. }
    5. function scenario() -> Result<int, string> {
    6. using file = (io.open("input.txt")?) {
    7. defer { io.writeLine("cleanup-observed") }
    8. divide(0)
    9. }
    10. Ok(0)
    11. }
    12. let result = scenario()
    Ожидаемый выводКод завершения 1
    Нет стандартного вывода.
    $ topaz run example.tpz · Целевой продукт 5.21.3
    input.txtAn ordinary fault skips remaining cleanup
    1. payload
    Ожидаемый результат

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

    Этап отклонения run. Код завершения 1.

    The division fault stops execution. The remaining defer and using cleanup are skipped under the fault cleanup rule. Standard output contains no cleanup message.

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

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

    Причина

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

    Изменённые правила Using acquisition and cleanup order →Explicit close and failure boundaries →

    Решённые открытые вопросы Using cleanup on each exit path →

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

    Выведенная реализация вызывает реализацию вложенного типа

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

    Проблема

    У поля может быть своё сравнение или преобразование JSON. Если при выводе обработки внешней записи смотреть лишь на структуру поля, это поведение потеряется.

    Решение

    • Вызывается явная или выведенная реализация внутреннего типа. Рекурсивные объявления связываются ссылками на описатели.
    • Цикл значений JSON возвращает Err. Цикл сравнения вызывает TPZ5007.

    Примеры

    Derived equality and operators use the inner manual equality

    example.tpzDerived equality and operators use the inner manual equality
    1. import std.io { writeLine }
    2. record Token { key: int, noise: int }
    3. impl Eq<Token> {
    4. function equals(a: Token, b: Token) -> bool { a.key == b.key }
    5. }
    6. record Box derives Eq { item: Token }
    7. let a = Box { item: Token { key: 1, noise: 10 } }
    8. let b = Box { item: Token { key: 1, noise: 20 } }
    9. let c = Box { item: Token { key: 2, noise: 10 } }
    10. writeLine("{Eq.equals(a, b)}")
    11. writeLine("{a == b}")
    12. writeLine("{Eq.equals(a, c)}")
    13. writeLine("{a != c}")
    Ожидаемый выводКод завершения 0
    true
    true
    false
    true
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Derived ordering and operators use the inner manual ordering

    example.tpzDerived ordering and operators use the inner manual ordering
    1. import std.io { writeLine }
    2. record Rank { score: int }
    3. impl Order<Rank> {
    4. function compare(a: Rank, b: Rank) -> int {
    5. if (a.score > b.score) { -1 } else if (a.score < b.score) { 1 } else { 0 }
    6. }
    7. }
    8. record Box derives Order { item: Rank }
    9. let a = Box { item: Rank { score: 9 } }
    10. let b = Box { item: Rank { score: 3 } }
    11. writeLine("{Order.compare(a, b)}")
    12. writeLine("{a < b}")
    13. writeLine("{Order.compare(b, a)}")
    14. writeLine("{b > a}")
    Ожидаемый выводКод завершения 0
    -1
    true
    1
    true
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Derived JSON uses the nested manual codec in both directions

    example.tpzDerived JSON uses the nested manual codec in both directions
    1. import std.io { writeLine }
    2. import std.json { JSONValue, parseAs, stringify }
    3. record Token { text: string }
    4. impl JSON<Token> {
    5. function encode(value: Token) -> Result<JSONValue, string> {
    6. JSON.encode(value.text)
    7. }
    8. function decode(value: JSONValue) -> Result<Token, string> {
    9. match (value.asString()) {
    10. case Some(text) => Ok(Token { text: text })
    11. case None() => Err("expected token string")
    12. }
    13. }
    14. }
    15. record Envelope derives JSON { token: Token }
    16. let text = match (stringify(Envelope { token: Token { text: "paper" } })) {
    17. case Ok(value) => value
    18. case Err(message) => message
    19. }
    20. writeLine(text)
    21. writeLine(match (parseAs<Envelope>(text)) {
    22. case Ok(value) => value.token.text
    23. case Err(message) => message
    24. })
    Ожидаемый выводКод завершения 0
    {"token":"paper"}
    paper
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    A finite recursive enum value encodes and decodes

    example.tpzA finite recursive enum value encodes and decodes
    1. import std.io { writeLine }
    2. import std.json { parseAs, stringify }
    3. enum Chain derives Eq, JSON { End, Next(int, Chain) }
    4. let original = Chain.Next(7, Chain.End())
    5. let text = match (stringify(original)) {
    6. case Ok(value) => value
    7. case Err(message) => message
    8. }
    9. writeLine(text)
    10. writeLine(match (parseAs<Chain>(text)) {
    11. case Ok(value) => "{Eq.equals(value, original)}"
    12. case Err(message) => message
    13. })
    Ожидаемый выводКод завершения 0
    {"tag":"Next","values":[7,{"tag":"End"}]}
    true
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. {"tag":"Next","values":[7,{"tag":"End"}]}
    2. true

    Inserted values keep recursive JSON finite

    example.tpzInserted values keep recursive JSON finite
    1. import std.io { writeLine }
    2. import std.json { stringify }
    3. record Node derives JSON { children: Array<Node> }
    4. let mut children: Array<Node> = []
    5. let root = Node { children: children }
    6. children.push(root)
    7. writeLine("{root.children.length}:{children.length}")
    8. writeLine(match (stringify(root)) {
    9. case Ok(value) => "Ok {value}"
    10. case Err(_) => "unexpected error"
    11. })
    Ожидаемый выводКод завершения 0
    0:1
    Ok {"children":[]}
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. 0:1
    2. Ok {"children":[]}

    Inserted values keep recursive comparison finite

    example.tpzInserted values keep recursive comparison finiteОткрыть песочницу →
    1. import std.io { writeLine }
    2. record Node derives Eq { children: Array<Node> }
    3. let mut children: Array<Node> = []
    4. let root = Node { children: children }
    5. let peer = Node { children: children }
    6. children.push(root)
    7. writeLine("{Eq.equals(root, peer)}:{root.children.length}:{children.length}")
    Ожидаемый выводКод завершения 0
    true:0:1
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

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

    Причина

    Вложенный тип сохраняет собственную реализацию.

    Изменённые правила Nested and recursive derivation requirements →

    Для newtype реализации выводятся явно

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

    Проблема

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

    Решение

    Указывайте протоколы в derives у newtype так же, как у записей и перечислений.

    Примеры

    Derive the existing protocols for a newtype

    example.tpzDerive the existing protocols for a newtype
    1. newtype Item derives Eq, Order, Show, JSON = int
    2. function jsonIdentity<T: JSON>(value: T) -> T { value }
    3. let value = Item(7)
    4. let same: bool = Eq.equals(value, value)
    5. let order: int = Order.compare(value, Item(8))
    6. let shown: string = Show.show(value)
    7. let retained: Item = jsonIdentity(value)
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

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

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

    Причина

    Номинальные типы одинаково показывают выведенные возможности.

    Изменённые правила Nested and recursive derivation requirements →Newtype derivation →

    Равенство, порядок и JSON имеют разные требования к типам

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

    Проблема

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

    Решение

    • Равенство Map и Set определяется составом элементов.
    • Order задаёт составимый полный порядок. В сравнении используется порядок имён полей и вариантов независимо от места их объявления.
    • JSON опирается на определённые преобразования, в том числе для конечных вещественных чисел и Result.

    Примеры

    Map and Set equality follows membership while Map values use Eq

    example.tpzMap and Set equality follows membership while Map values use Eq
    1. import std.io { writeLine }
    2. record Token { key: int, label: string }
    3. impl Eq<Token> {
    4. function equals(a: Token, b: Token) -> bool { a.key == b.key }
    5. }
    6. record Index derives Eq { values: Map<string, Token>, keys: Set<int> }
    7. let a = Index {
    8. values: map { "a": Token { key: 1, label: "first" }, "b": Token { key: 2, label: "second" } },
    9. keys: set { 1, 2 },
    10. }
    11. let b = Index {
    12. values: map { "b": Token { key: 2, label: "changed" }, "a": Token { key: 1, label: "changed" } },
    13. keys: set { 2, 1 },
    14. }
    15. let c = Index {
    16. values: map { "a": Token { key: 9, label: "first" }, "b": Token { key: 2, label: "second" } },
    17. keys: set { 1, 2 },
    18. }
    19. writeLine("{Eq.equals(a, b)}")
    20. writeLine("{a == b}")
    21. writeLine("{Eq.equals(a, c)}")
    Ожидаемый выводКод завершения 0
    true
    true
    false
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Reordering record fields or enum declarations does not change derived order

    example.tpzReordering record fields or enum declarations does not change derived order
    1. import std.io { writeLine }
    2. record First derives Order { z: int, a: int }
    3. record Second derives Order { a: int, z: int }
    4. enum Forward derives Order { Zed, Alpha }
    5. enum Reordered derives Order { Alpha, Zed }
    6. writeLine("{Order.compare(First { z: 0, a: 2 }, First { z: 100, a: 1 })}")
    7. writeLine("{Order.compare(Second { z: 0, a: 2 }, Second { z: 100, a: 1 })}")
    8. writeLine("{Order.compare(Forward.Alpha(), Forward.Zed())}")
    9. writeLine("{Order.compare(Reordered.Alpha(), Reordered.Zed())}")
    Ожидаемый выводКод завершения 0
    1
    1
    -1
    -1
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Finite floats have one JSON number conversion and preserve negative zero

    example.tpzFinite floats have one JSON number conversion and preserve negative zero
    1. import std.io { writeLine }
    2. import std.json { parseAs, stringify }
    3. record Reading derives JSON { value: float }
    4. writeLine(match (stringify(Reading { value: 1.5 })) {
    5. case Ok(text) => text
    6. case Err(message) => message
    7. })
    8. writeLine(match (stringify(-0.0)) {
    9. case Ok(text) => text
    10. case Err(message) => message
    11. })
    12. writeLine(match (stringify(1000.0)) {
    13. case Ok(text) => text
    14. case Err(message) => message
    15. })
    16. writeLine(match (parseAs<float>("-0")) {
    17. case Ok(value) => "{(1.0 / value) < 0.0}"
    18. case Err(message) => message
    19. })
    20. writeLine(match (parseAs<float>("1")) {
    21. case Ok(value) => "{value == 1.0}"
    22. case Err(message) => message
    23. })
    24. writeLine(match (stringify(0.0 / 0.0)) {
    25. case Ok(_) => "unexpected value"
    26. case Err(_) => "nonfinite rejected"
    27. })
    28. writeLine(match (parseAs<float>("1e9999")) {
    29. case Ok(_) => "unexpected value"
    30. case Err(_) => "overflow rejected"
    31. })
    Ожидаемый выводКод завершения 0
    {"value":1.5}
    -0
    1000
    true
    true
    nonfinite rejected
    overflow rejected
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. {"value":1.5}
    2. -0
    3. 1000
    4. true
    5. true
    6. nonfinite rejected
    7. overflow rejected

    Result data uses the same tagged representation as enum data

    example.tpzResult data uses the same tagged representation as enum data
    1. import std.io { writeLine }
    2. import std.json { parseAs, stringify }
    3. record Outcome derives JSON { value: Result<int, string> }
    4. let value = Outcome { value: Err("paper") }
    5. let text = match (stringify(value)) {
    6. case Ok(encoded) => encoded
    7. case Err(message) => message
    8. }
    9. writeLine(text)
    10. writeLine(match (parseAs<Outcome>(text)) {
    11. case Ok(decoded) => match (decoded.value) {
    12. case Ok(number) => "{number}"
    13. case Err(message) => message
    14. }
    15. case Err(message) => message
    16. })
    Ожидаемый выводКод завершения 0
    {"value":{"tag":"Err","values":["paper"]}}
    paper
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. {"value":{"tag":"Err","values":["paper"]}}
    2. paper

    Map membership has no implicit total ordering

    example.tpzMap membership has no implicit total orderingОткрыть песочницу →
    1. record Lookup derives Order { values: Map<string, int> }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    • TPZ5530 →

      structures-derive-order-field at example.tpz:1:23

    A Set needs an explicitly chosen JSON representation

    example.tpzA Set needs an explicitly chosen JSON representationОткрыть песочницу →
    1. record Membership derives JSON { values: Set<int> }
    Ожидаемый выводНенулевой код завершения
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    • TPZ5530 →

      structures-derive-json-field at example.tpz:1:27

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

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

    Причина

    Поддержку каждой операции можно определить по её смыслу.

    Изменённые правила Field capability domains for derivation →

    Протоколы следуют общим правилам имён модулей

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

    Проблема

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

    Решение

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

    Примеры

    A selected protocol alias preserves a public conformance

    example.tpzA selected protocol alias preserves a public conformance
    1. import std.io { writeLine }
    2. import contracts { Labelled as Described }
    3. import item { Item }
    4. function describe<T: Described>(value: T) -> string { Described.label(value) }
    5. writeLine(describe(Item { text: "selected" }))
    Ожидаемый выводКод завершения 0
    selected
    
    $ topaz run example.tpz --language-version 6.0
    contracts.tpzA selected protocol alias preserves a public conformance
    1. export protocol Labelled { function label(value: Self) -> string }
    item.tpzA selected protocol alias preserves a public conformance
    1. import contracts { Labelled }
    2. export record Item { text: string }
    3. impl Labelled<Item> {
    4. function label(value: Item) -> string { value.text }
    5. }
    Ожидаемый результат

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

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

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

    A namespace-qualified protocol resolves in bounds, impl heads, and calls

    example.tpzA namespace-qualified protocol resolves in bounds, impl heads, and calls
    1. import std.io { writeLine }
    2. import contracts as api
    3. import item { Item }
    4. function describe<T: api.Labelled>(value: T) -> string { api.Labelled.label(value) }
    5. writeLine(describe(Item { text: "qualified" }))
    Ожидаемый выводКод завершения 0
    qualified
    
    $ topaz run example.tpz --language-version 6.0
    contracts.tpzA namespace-qualified protocol resolves in bounds, impl heads, and calls
    1. export protocol Labelled { function label(value: Self) -> string }
    item.tpzA namespace-qualified protocol resolves in bounds, impl heads, and calls
    1. import contracts as api
    2. export record Item { text: string }
    3. impl api.Labelled<Item> {
    4. function label(value: Item) -> string { value.text }
    5. }
    Ожидаемый результат

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

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

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

    Equal protocol spellings in different modules keep different conformances

    example.tpzEqual protocol spellings in different modules keep different conformances
    1. import std.io { writeLine }
    2. import first { Marked as First }
    3. import second { Marked as Second }
    4. import value { Item }
    5. function printBoth<T: First + Second>(value: T) -> () {
    6. writeLine(First.mark(value))
    7. writeLine(Second.mark(value))
    8. }
    9. printBoth(Item { text: "value" })
    Ожидаемый выводКод завершения 0
    first value
    second value
    
    $ topaz run example.tpz --language-version 6.0
    value.tpzEqual protocol spellings in different modules keep different conformances
    1. export record Item { text: string }
    first.tpzEqual protocol spellings in different modules keep different conformances
    1. import value { Item }
    2. export protocol Marked { function mark(value: Self) -> string }
    3. impl Marked<Item> { function mark(value: Item) -> string { "first {value.text}" } }
    second.tpzEqual protocol spellings in different modules keep different conformances
    1. import value { Item }
    2. export protocol Marked { function mark(value: Self) -> string }
    3. impl Marked<Item> { function mark(value: Item) -> string { "second {value.text}" } }
    Ожидаемый результат

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

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

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

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

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

    Причина

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

    Изменённые правила Conformance follows nominal origin across imports →

    Ограничения обобщённой реализации пишутся в начальном списке параметров

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

    Проблема

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

    Решение

    • Помещайте ограничения в начальный список параметров, как в impl<T: Eq> Eq<Box<T>>.
    • Условный вывод пишется как derives<T: Eq> Eq<Box<T>>.

    Примеры

    Implement equality for a generic wrapper

    example.tpzImplement equality for a generic wrapper
    1. record Box<T> { value: T }
    2. impl<T: Eq> Eq<Box<T>> {
    3. function equals(a: Box<T>, b: Box<T>) -> bool {
    4. Eq.equals(a.value, b.value)
    5. }
    6. }
    7. let left: Box<int> = Box { value: 3 }
    8. let right: Box<int> = Box { value: 3 }
    9. let same: bool = Eq.equals(left, right)
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Derive equality under an element bound

    example.tpzDerive equality under an element bound
    1. record Box<T> derives<T: Eq> Eq<Box<T>> { value: T }
    2. let left: Box<int> = Box { value: 3 }
    3. let right: Box<int> = Box { value: 3 }
    4. let same: bool = Eq.equals(left, right)
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Use the conditional derive binder on a newtype

    example.tpzUse the conditional derive binder on a newtype
    1. newtype Box<T> derives<T: Eq> Eq<Box<T>> = T
    2. let left: Box<int> = Box(3)
    3. let right: Box<int> = Box(3)
    4. let same: bool = Eq.equals(left, right)
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

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

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

    Причина

    Требования протокола находятся в одном месте в обоих объявлениях.

    Изменённые правила Generic binders and conditional conformance →

    Решённые открытые вопросы Generic implementation syntax →

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

    Обобщённые реализации протоколов используют синтаксис ограничений функций

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

    Проблема

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

    Решение

    • Реализация протокола может объявлять явные параметры типа и ограничения, быть условной или выводиться при выполнении условий.
    • Используются формы impl<T: Eq> Eq<Box<T>> и derives<T: Eq> Eq<Box<T>>.

    Примеры

    Implement equality for a generic wrapper →

    Derive equality under an element bound →

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

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

    Причина

    У функций и реализаций один синтаксис ограничений, а обобщённым типам доступны существующие операции протоколов.

    Изменённые правила Generic binders and conditional conformance →

    Решённые открытые вопросы Generic implementations and conditional derivation →Generic implementation syntax →

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

    Коллекции получают ожидаемые типы из контекста

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

    Проблема

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

    Решение

    Ожидаемые типы одинаково передаются массивам, множествам, отображениям и генераторам.

    Примеры

    Array comprehension with an expected literal type

    example.tpzArray comprehension with an expected literal type
    1. let array: Array<1> = [for item in ([0]) => 1]
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Set comprehension with an expected literal type

    example.tpzSet comprehension with an expected literal type
    1. let keys: Set<1> = set { for item in ([0]) => 1 }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Map comprehension with an expected literal type

    example.tpzMap comprehension with an expected literal type
    1. let table: Map<1, "one"> = map { for item in ([0]) => 1: "one" }
    Ожидаемый выводКод завершения 0
    Нет стандартного вывода.
    $ topaz check example.tpz --language-version 6.0 --format json
    Ожидаемый результат

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

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

    Give empty collections a contextual type

    example.tpzGive empty collections a contextual typeОткрыть песочницу →
    1. let values: Array<int> = []
    2. let names: Set<string> = set {}
    3. let counts: Map<string, int> = map {}
    Ожидаемый выводКод завершения 0
    example.tpz: types-ok (1 module)
    example.tpz: resolve-ok (1 module)
    
    $ topaz check example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. example.tpz: types-ok (1 module)
    2. example.tpz: resolve-ok (1 module)

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

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

    Причина

    Тип результата указывается одинаково для всех коллекций.

    Изменённые правила Context for empty collections →Array comprehension type →Set comprehension type →Map comprehension type →

    Обратные вызовы объединяют преобразования, а генераторы строят коллекции

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

    Проблема

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

    Решение

    • Сохраняются методы вроде arr.map(f) для цепочек преобразований и генераторы для сборки коллекции из источников с фильтрами.
    • Если обе формы дают одинаковый результат, спецификация всё равно указывает, когда и в каком порядке вычисляется каждая.

    Примеры

    Reuse functions through callback methods

    example.tpzReuse functions through callback methodsОткрыть песочницу →
    1. import std.io
    2. function addPadding(width: int) -> int { width + 2 }
    3. function double(width: int) -> int { width * 2 }
    4. let widths = [10, 20]
    5. let chained = widths.map(addPadding).map(double)
    6. let constructed = [for width in (widths) => double(addPadding(width))]
    7. for width in (chained) {
    8. io.writeLine("callback {width}")
    9. }
    10. for width in (constructed) {
    11. io.writeLine("comprehension {width}")
    12. }
    Ожидаемый выводКод завершения 0
    callback 24
    callback 44
    comprehension 24
    comprehension 44
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Construct a collection from filtered sources

    example.tpzConstruct a collection from filtered sourcesОткрыть песочницу →
    1. import std.io
    2. let widths = [10, 20]
    3. let paddings = [1, 2]
    4. let outerWidths = [for width in (widths) if (width > 10) for padding in (paddings) => width + padding * 2]
    5. for width in (outerWidths) {
    6. io.writeLine("{width}")
    7. }
    Ожидаемый выводКод завершения 0
    22
    24
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Observe complete callback passes and per-element comprehension work

    example.tpzObserve complete callback passes and per-element comprehension workОткрыть песочницу →
    1. import std.io
    2. function source() -> Array<int> {
    3. io.writeLine("source")
    4. [1, 2, 3]
    5. }
    6. function selected(value: int) -> bool {
    7. io.writeLine("select {value}")
    8. value > 1
    9. }
    10. function convert(value: int) -> int {
    11. io.writeLine("convert {value}")
    12. value * 10
    13. }
    14. function predicate() -> (int) -> bool {
    15. io.writeLine("predicate")
    16. selected
    17. }
    18. function transformation() -> (int) -> int {
    19. io.writeLine("transformation")
    20. convert
    21. }
    22. io.writeLine("callback chain")
    23. let chained = source().filter(predicate()).map(transformation())
    24. io.writeLine("comprehension")
    25. let constructed = [for value in (source()) if (selected(value)) => convert(value)]
    26. io.writeLine("results")
    27. for value in (chained) {
    28. io.writeLine("callback {value}")
    29. }
    30. for value in (constructed) {
    31. io.writeLine("comprehension {value}")
    32. }
    Ожидаемый выводКод завершения 0
    callback chain
    source
    predicate
    select 1
    select 2
    select 3
    transformation
    convert 2
    convert 3
    comprehension
    source
    select 1
    select 2
    convert 2
    select 3
    convert 3
    results
    callback 20
    callback 30
    comprehension 20
    comprehension 30
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. callback chain
    2. source
    3. predicate
    4. select 1
    5. select 2
    6. select 3
    7. transformation
    8. convert 2
    9. convert 3
    10. comprehension
    11. source
    12. select 1
    13. select 2
    14. convert 2
    15. select 3
    16. convert 3
    17. results
    18. callback 20
    19. callback 30
    20. comprehension 20
    21. comprehension 30

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

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

    Причина

    Построение коллекции можно отличить от цепочки функций.

    Изменённые правила Callback methods and comprehensions →

    Массивы, множества и диапазоны используют общие методы обратного вызова

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

    Проблема

    Преобразование массива может понадобиться для множества или диапазона. Менять форму на цикл из-за типа получателя не требуется.

    Решение

    • Массивы, множества и диапазоны предоставляют немедленные map, filter и reduce.
    • map и filter возвращают массивы в порядке обхода, а reduce возвращает накопленное значение.

    Примеры

    Transform sets and ranges with callback methods

    example.tpzTransform sets and ranges with callback methodsОткрыть песочницу →
    1. import std.io
    2. let marks = set { 3, 1, 2 }
    3. let doubled: Array<int> = marks.map((value: int) => value * 2)
    4. let evens: Array<int> = (1..6).filter((value: int) => value % 2 == 0)
    5. let total = (1..4).reduce(0, (sum: int, value: int) => sum + value)
    6. for value in (doubled) {
    7. io.writeLine("set {value}")
    8. }
    9. for value in (evens) {
    10. io.writeLine("range {value}")
    11. }
    12. io.writeLine("total {total}")
    Ожидаемый выводКод завершения 0
    set 6
    set 2
    set 4
    range 2
    range 4
    range 6
    total 10
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

    Reuse functions through callback methods →

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

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

    Причина

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

    Изменённые правила Callback methods and comprehensions →

    Отображения и множества сохраняют порядок вставки

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

    Проблема

    Замена значения или удаление элемента не должны неожиданно менять обход. Равенство и порядок обхода решают разные задачи.

    Решение

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

    Примеры

    Keep a Map key in place when replacing its value

    example.tpzKeep a Map key in place when replacing its valueОткрыть песочницу →
    1. import std.io { writeLine }
    2. let mut values = map { "first": 1, "middle": 2, "last": 3 }
    3. values.insert("middle", 20)
    4. for key in (values.keys) { writeLine(key) }
    5. for value in (values.values) { writeLine("{value}") }
    6. for entry in (values.entries) { writeLine("{entry.key}={entry.value}") }
    7. writeLine("{values}")
    Ожидаемый выводКод завершения 0
    first
    middle
    last
    1
    20
    3
    first=1
    middle=20
    last=3
    Map{first: 1, middle: 20, last: 3}
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. first
    2. middle
    3. last
    4. 1
    5. 20
    6. 3
    7. first=1
    8. middle=20
    9. last=3
    10. Map{first: 1, middle: 20, last: 3}

    Keep surviving Map entries in order after removal

    example.tpzKeep surviving Map entries in order after removalОткрыть песочницу →
    1. import std.io { writeLine }
    2. let mut values = map { "first": 1, "removed": 2, "third": 3, "last": 4 }
    3. values.remove("removed")
    4. for entry in (values.entries) { writeLine("{entry.key}={entry.value}") }
    5. writeLine("{values}")
    Ожидаемый выводКод завершения 0
    first=1
    third=3
    last=4
    Map{first: 1, third: 3, last: 4}
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

    Ожидаемый стандартный вывод
    1. first=1
    2. third=3
    3. last=4
    4. Map{first: 1, third: 3, last: 4}

    Keep surviving Set elements in order after removal

    example.tpzKeep surviving Set elements in order after removalОткрыть песочницу →
    1. import std.io { writeLine }
    2. let mut values = set { 3, 1, 4, 2 }
    3. values.add(1)
    4. values.remove(1)
    5. for value in (values) { writeLine("{value}") }
    6. writeLine("{values}")
    Ожидаемый выводКод завершения 0
    3
    4
    2
    Set{3, 4, 2}
    
    $ topaz run example.tpz --language-version 6.0
    Ожидаемый результат

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

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

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

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

    • Заполнять удалённое место последним элементом. Удаление изменило бы порядок элементов, которые оставили.
    • Не определять порядок. Результаты не повторялись бы.
    • Использовать отсортированный порядок. Порядок вставки совпадает с Set и с нынешним поведением, поэтому примеры не меняются.

    Причина

    Из кода вставки и удаления можно предвидеть порядок обхода и вывода.

    Изменённые правила Map and Set insertion order →Set order and duplicate elements →