본문으로 건너뛰기
토파즈문서

문서 검색

명세 6.0

방향키로 결과를 고르고 Enter를 눌러 여세요.

API 이름, 진단 번호, 규칙 또는 프로젝트 주제를 입력하세요.

    다운로드 →

    설계 결정

    구조

    십진 반올림 방식은 일반 열거형입니다

    2026년 11월 17일 채택 · 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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    • TPZ5712 →

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

    검토한 대안

    • 특례 타입은 유지하고 생성자 패턴만 추가한다. 패턴은 쓸 수 있어도 키 등 다른 용도의 특례가 남습니다.
    • 패턴을 막고 ==만 허용한다. 망라 match가 거절되고 생성자가 두 종류가 됩니다.

    이유

    다른 인자 없는 열거형에서 익힌 사용법을 반올림 방식에도 쓸 수 있습니다.

    바뀐 규칙 Variants without payloads →Every match is exhaustive →

    열거형의 값에는 열거형을 포함한 합집합도 넣을 수 있습니다

    2026년 11월 7일 채택 · 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 →

    열거형 변형은 표준 생성자와 같은 이름을 쓸 수 있습니다

    2026년 11월 7일 채택 · 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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    • 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 →

    구조적 레코드 갱신에서는 필드마다 한 번만 씁니다

    2026년 11월 7일 채택 · 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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    • 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 →

    생성자는 값 자리에서도 인자 목록을 씁니다

    2026년 11월 18일 채택 · 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
    기대 출력0이 아닌 종료 코드
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    필수 기본 위치 계약은 미정입니다.

    Bare empty variant is rejected

    example.tpzBare empty variant is rejected
    1. enum Choice { Full(int), Empty }
    2. let value = Choice.Empty
    기대 출력0이 아닌 종료 코드
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    필수 기본 위치 계약은 미정입니다.

    Bare Some is rejected

    example.tpzBare Some is rejected
    1. let make = Some
    기대 출력0이 아닌 종료 코드
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    필수 기본 위치 계약은 미정입니다.

    Bare Ok is rejected

    example.tpzBare Ok is rejected
    1. let make = Ok
    기대 출력0이 아닌 종료 코드
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    필수 기본 위치 계약은 미정입니다.

    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로 씁니다

    2026년 11월 7일 채택 · 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" })
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 parse. 종료 코드가 0이 아닙니다.

    • 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 →

    프로토콜 서명은 일반 함수의 선언 규칙을 씁니다

    2026년 11월 7일 채택 · 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 →

    프로토콜 구현은 선언의 기본값과 공개 범위를 따릅니다

    2026년 11월 7일 채택 · 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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    • TPZ5521 →

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

    검토한 대안

    • 구현마다 별도 함수와 우선순위를 둔다. 기본값과 가시성을 다시 확인해야 하고 선언 순서가 구현 선택에 영향을 줍니다.
    • 구현 메서드의 지금 제한을 둔다. 기본값과 공개성의 주인이 하나여야 합니다.

    이유

    호출의 기본값과 어떤 구현이 적용되는지 계약에서 읽을 수 있습니다.

    바뀐 규칙 Implementation methods use ordinary functions →One conformance across the dependency graph →

    가져온 타입의 프로토콜 가시성은 구현 방식과 무관합니다

    2026년 11월 7일 채택 · 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를 씁니다

    2026년 11월 7일 채택 · 6.0.0 · 구현 중

    문제

    자동으로 만든 변환 외에 직접 JSON 변환을 정의할 때가 있습니다. 변환 방법과 JSON 트리를 값으로 읽는 호출을 어디에 둘지 정해야 합니다.

    결정

    • 직접 구현한 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> {}
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    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. }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0 --format json
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    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 트리를 읽는 방법이 하나입니다.

    바뀐 규칙 JSON conformance →

    using은 정상 종료와 구조적 조기 종료에서 정리합니다

    2026년 11월 7일 채택 · 5.21 계열 · 확인 중

    문제

    블록을 끝까지 실행하거나 중간에 반환할 때 파일을 닫아야 합니다. 실행 오류나 같은 파일을 다시 닫을 때도 이 보장이 적용되는지 명세가 밝혀야 합니다.

    결정

    • 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 →

    판 이력

    파생 구현은 안쪽 타입의 프로토콜 구현을 호출합니다

    2026년 11월 7일 채택 · 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 →

    새 명목 타입도 derives를 명시합니다

    2026년 11월 7일 채택 · 6.0.0 · 구현 중

    문제

    기저 타입이 프로토콜을 지원할 때 새 이름으로 만든 타입이 이를 따라야 할지 정해야 합니다. 자동으로 물려받으면 새 타입이 허용하는 동작이 선언에서 보이지 않습니다.

    결정

    newtype도 레코드나 열거형처럼 필요한 프로토콜을 derives로 명시합니다.

    예제

    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의 파생을 지금처럼 금지한다. conformance를 얻는 규칙이 명목 타입마다 같아야 합니다.

    이유

    같은 명목 타입 규칙으로 어떤 프로토콜이 제공되는지 읽을 수 있습니다.

    바뀐 규칙 Nested and recursive derivation requirements →Newtype derivation →

    동등성, 순서, JSON 변환은 각 연산의 조건을 따릅니다

    2026년 11월 7일 채택 · 6.0.0 · 구현 중

    문제

    값을 비교할 수 있다고 해서 순서를 매기거나 JSON으로 내보낼 수 있는 것은 아닙니다. 필드 선언의 줄 순서를 바꾸는 작업도 비교 결과에 영향을 줄 수 있습니다.

    결정

    • Map과 Set의 Eq는 포함되는 항목을 기준으로 합니다.
    • 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> }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    • 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> }
    기대 출력0이 아닌 종료 코드
    표준 출력 없음.
    $ topaz check example.tpz --language-version 6.0
    기대 결과

    기대 결과

    거절 단계 check. 종료 코드가 0이 아닙니다.

    • TPZ5530 →

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

    검토한 대안

    • 고정 허용 목록에 기대거나 모든 타입을 허용한다. 목록은 서로 다른 연산 요건을 설명하지 못하고 무조건 허용하면 계약을 만족하지 않는 타입도 들어옵니다.

    이유

    어떤 타입이 동등성, 순서, JSON 변환을 각각 지원하는지 그 연산의 의미로 판단할 수 있습니다.

    바뀐 규칙 Field capability domains for derivation →

    프로토콜은 일반 모듈 이름 규칙을 따릅니다

    2026년 11월 7일 채택 · 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 →

    제네릭 프로토콜 구현의 제약은 앞쪽 매개변수에 씁니다

    2026년 11월 7일 채택 · 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 →

    판 이력

    제네릭 프로토콜 구현은 함수와 같은 제약 문법을 씁니다

    2026년 11월 7일 채택 · 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 →

    판 이력

    컬렉션은 만드는 자리의 기대 타입을 따릅니다

    2026년 11월 7일 채택 · 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 →

    콜백 메서드는 변환을 잇고 컴프리헨션은 원천을 모읍니다

    2026년 11월 7일 채택 · 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 →

    배열과 집합과 범위에 같은 콜백 메서드를 씁니다

    2026년 11월 14일 채택 · 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 →

    맵과 집합은 삽입 순서를 보존합니다

    2026년 11월 9일 채택 · 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 →