Scope and ownership
링크This page covers nominal declarations, their fields and variants, construction, record updates, and declaration type parameters.
General type compatibility belongs to Types. Protocols and implementations owns conformance, derives requirements, and method resolution. Receiver APIs and pattern matching have their own references.
Declaration syntax
링크RecordDeclaration ="record" Identifier NominalTypeParameters? DerivesClause?"{" (RecordField ("," RecordField)* ","?)? "}" ;RecordField = Identifier ":" Type ("=" Expression)? ;EnumDeclaration ="enum" Identifier NominalTypeParameters? DerivesClause?"{" (Variant ("," Variant)* ","?)? "}" ;Variant = Identifier ("(" Type ("," Type)* ")")? ;NewtypeDeclaration ="newtype" Identifier NominalTypeParameters? DerivesClause? "=" Type ;NominalTypeParameters ="<" Identifier ("," Identifier)* ">" ;DerivesClause ="derives" (Identifier ("," Identifier)*| FunctionTypeParameters ConditionalConformance ("," ConditionalConformance)*) ;ConditionalConformance = Identifier "<" Type ">" ;
The excerpt uses Identifier, Type, and Expression from their respective language definitions. Export placement and declaration contexts are covered separately.
Named and typed record fields
A record declaration gives each field a name and a type.
이유
Named fields give each part of a record one identity. Declared types let construction, access, and updates share the same checks.
Enum variants and payload types
An enum declaration lists named variants with optional positional payload types.
이유
A variant names one alternative, and its payload carries the data needed for that alternative. Declared payload types make matching and construction agree.
A newtype base type
A newtype declaration names one base type after =.
이유
A newtype gives one existing value type a distinct identity. One base type preserves that wrapper relationship without introducing another record shape.
Derives clause placement
A nominal derives clause follows the declaration name and type parameters. It precedes the body of a record or enum, or = and the base type of a newtype.
이유
Placing derivation beside the type name makes generated protocol behavior visible before the representation. Records, enums, and newtypes use the same clause position after the name and type parameters.
Newtype derivation
A newtype declaration may request the same derived protocols as a record or enum. Its base type supplies the member capability checks. Derivation is explicit; the base type does not implicitly give the newtype a protocol conformance. The clause precedes = and accepts the same conditional generic binder.
이유
A newtype has a distinct nominal identity even when its representation is an existing type. Explicit derivation lets it opt into the same protocol contracts as records and enums. Inspecting the base type uses the existing capability rules without introducing implicit conformance inheritance or a wrapper-specific prohibition.
Record fields and construction
링크Construct a record and supply a spread value
링크record Point { x: int, y: int = 0 }let point = Point { x: 1 }let moved = Point { ...point, y: 2 }
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
Declaring a field default
A record field default is an expression written after its type and =.
이유
The field type states the required value shape, and the following initializer supplies its default. This matches the type and initializer order used by bindings.
Repeated field declarations
Declaring the same field name twice in one record produces TPZ5008.
이유
Each field name must identify one stored value and one declared type. Duplicate declarations would make access and construction ambiguous.
Required construction fields
A named record construction without a spread produces TPZ5004 when it omits a field with no default.
이유
A constructed record must contain a value for every field. Requiring fields without defaults prevents a later read from encountering uninitialized data.
Omitting a defaulted field
A named record construction may omit a field that has a declared default.
이유
A declaration supplies the shared default for each omitted field. Call sites can use that policy without repeating the initializer expression.
Repeated construction fields
Supplying the same field twice in a named record construction produces TPZ5008.
이유
A field must receive one explicit initializer. Rejecting duplicates avoids choosing a value by overwrite order and evaluating a discarded initializer.
Undeclared construction fields
Supplying a field absent from the declared record produces TPZ5006.
이유
Rejecting undeclared names catches misspellings at construction. It also keeps every stored field within the record type that later access checks use.
Construction field types
A named construction checks each uniquely supplied field against its resolved declared type after substituting record type arguments.
이유
Reads rely on the declared field type. Checking supplied values after generic substitution preserves that guarantee for each record instantiation.
Evaluation of omitted record fields
Each construction evaluates defaults for omitted fields after its explicit initializers, in field declaration order. A supplied field or a spread supplies the field instead. Defaults refer to names in their declaration environment.
이유
A fresh evaluation gives each construction its own default values. The declaration environment keeps defaults independent of names at the call site, and a fixed order makes effects predictable.
Declared types also constrain defaults
A record field default must satisfy the declared field type. A string default for an int field is a type error.
이유
A default can become the field value without an explicit initializer at a call site. Checking it against the declared type preserves the same requirement for both paths.
Record literals and updates
링크NominalRecordConstruction =Identifier "{" RecordContents? "}" ;RecordContents =(RecordSpread ("," FieldInitializers)? | FieldInitializers) ","? ;RecordSpread = "..." Expression ;FieldInitializers = FieldInitializer ("," FieldInitializer)* ;FieldInitializer = FieldName ":" Expression ;StructuralRecordLiteral ="{" FieldInitializers ","? "}" ;RecordValueUpdate =Identifier "{" FieldInitializers ","? "}" ;
This excerpt shows nonempty updates with identifier bases. Types covers structural compatibility.
The name in a record construction
The name in a named record construction denotes a declared record.
이유
Resolving the head as a record type gives construction its field declarations and nominal identity. It does not depend on an unrelated value with that spelling.
Record spread placement
A spread in a named record construction must appear first and occur at most once.
이유
One initial spread gives construction a single base value. Explicit fields can then replace named values without competing spreads or an implicit overwrite order.
The type of a record spread
A named record construction checks the spread value against the constructed record type.
이유
The copied fields must belong to the record being constructed. Requiring the same instantiated record type prevents incompatible fields from entering through a spread.
Spreads on a value update
A spread on a record value update produces TPZ5001.
이유
A value update already names the record to copy. Another spread would introduce a second base and a choice of overwrite order.
Structural record literals
A structural record literal encloses at least one named field initializer in braces and has no nominal record name.
이유
Field names and values can describe a record without assigning a separate nominal identity. This supports small grouped values whose shape is their type.
Empty braces in expressions
In an expression, empty braces form a block.
이유
Empty braces in an expression denote an empty block. Keeping that reading makes empty bodies consistent and avoids selecting between a block and a record from context.
Record update evaluation and copied fields
A record update evaluates its base once before explicit field initializers. Initializers run in source order. A spread supplies omitted fields without reevaluating their defaults. The result has new record storage and retains the field values from the base.
이유
Evaluating the base once avoids duplicating its effects. Explicit fields then replace named values while omitted fields retain the copied values.
Structural record value updates
링크Update a structural record value
링크let point = { x: 1, y: 2 }let moved = point { y: 3 }let updated: int = moved.y
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
The base of a structural update
In a structural record update value { field: expression }, value denotes an existing structural record.
이유
An update needs an existing value to supply fields that are not replaced. Resolving the head in the value namespace identifies that source directly.
Structural update field types
For a field supplied once, a structural record update checks its value against the base record field type.
이유
Replacing a field must preserve the type used by existing readers. Checking against the base field type prevents an update from invalidating those readers.
Structural update result type
A structural record value update has the type of its base record.
이유
An update changes field values while preserving the record shape. Keeping the base type lets the result serve the same uses as the original value.
Update a nominal record through its declaration
Value-update syntax requires a structural record. Update a nominal record with its declared name and a spread, as in Point { ..
이유
Nominal updates use named construction with a leading spread. Rejecting a value-headed update keeps one update form for a nominal record.
Repeated structural update fields
Each explicit field name in a structural record update must occur once. Repeating a field is rejected with TPZ5008 even when an earlier initializer has an incompatible type. A field copied from the base may be replaced by one explicit initializer.
이유
Each explicit field must select one value. Rejecting repeated names prevents initializer order from choosing a winner or hiding an incompatible earlier value.
Enum variants and construction
링크Construct variants with and without payloads
링크enum Reply { Waiting, Done(int, string) }let waiting: Reply = Reply.Waiting()let done: Reply = Reply.Done(2, "ready")
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
See Pattern matching for variant patterns, exhaustiveness, and unreachable cases. Functions and generics covers argument binding.
Variants without payloads
Calling a qualified enum constructor without payloads, such as Choice., produces a value of the enum type.
이유
A bare nullary variant and a call with no arguments construct the same variant without a payload. Parentheses preserve that construction intent and use the same argument-list shape as variants with payloads and constructor patterns.
Variants with payloads
A payload-bearing enum variant is a constructor function from its substituted payload types to the enum type.
이유
A payload variant needs values before it can exist. Giving its constructor a function type reuses ordinary argument checking and function passing.
Variant names and prelude constructors
Enum variants may be named None, Some, Ok, or Err. Construct them through the enum name, such as Reply. or Reply.. The prelude Ok(value) constructs a Result value. An unqualified constructor pattern such as None() resolves through the normalized scrutinee type. Prelude spelling does not take priority. For a union, collect the constructor declarations with that head before checking payload arity. One declaration is required. Multiple instantiations of that same declaration project the union of the corresponding payload types. Distinct declarations with the same head are ambiguous even when their payload shapes agree. Narrow with an existing typed pattern and match the narrowed value. Ambiguity is a TPZ5001 pattern-type error. Wrong payload arity remains TPZ5004. Constructor patterns use unqualified heads.
이유
A constructor belongs to its defining nominal type. A prelude spelling must not reserve the same field-like name inside every enum. Resolving a pattern to one constructor keeps unrelated nominal types distinct. If a union introduces a second constructor with that name, requiring type narrowing prevents an existing arm from silently acquiring new cases. The ordinary typed pattern supplies that narrowing without another constructor notation.
Enum declarations and payload types
An enum declaration may have no variants. Nominal type names are predeclared, so enum payloads may refer to their own enum or another declared enum, including through Array. This admits the declaration; it does not create a value for an enum with no finite constructor path. Payloads follow the same union type rules as other type positions. A union payload may contain enum types.
이유
Nominal declarations establish type identities before values are constructed. Empty and recursive types can therefore be declared without requiring a finite value. Payloads compose the same type expressions used elsewhere. An enum member in a union must not require an extra wrapper or a different variant structure.
Unique enum variant declarations
Each variant name must be unique within its enum. The retained checker diagnoses repeated declarations with TPZ5008; current SELF appends them without that guard. The intended rejection remains a product expectation and the missing SELF check is an implementation limitation.
이유
A variant name must select one alternative within its enum. Reusing the name would make construction and pattern matching ambiguous.
Accept an enum type in a union payload
링크enum Inner { Leaf }enum Outer { Wrapped(Inner | int) }
표준 출력 없음.기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
Use distinct variants for distinct payload cases
링크enum Inner { Leaf }enum Outer { Wrapped(Inner), Number(int) }let value: Outer = Outer.Wrapped(Inner.Leaf())
표준 출력 없음.기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
Construct and match both union payload alternatives
링크import std.io { writeLine }enum Inner { Leaf }enum Outer { Wrapped(Inner | int) }function describe(value: Outer) -> string {match (value) {case Wrapped(payload) => match (payload) {case number: int => "{number}"case _ => "leaf"}}}writeLine(describe(Outer.Wrapped(Inner.Leaf())))writeLine(describe(Outer.Wrapped(7)))
leaf
7
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
leaf7
Enum variants and prelude constructors retain separate identities
링크import std.io { writeLine }enum Reply { None, Some(int), Ok(string), Err(bool) }function describe(value: Reply) -> string {match (value) {case None() => "enum none"case Some(number) => "enum some {number}"case Ok(text) => "enum ok {text}"case Err(flag) => if (flag) { "enum error" } else { "enum false" }}}function option(value: Option<int>) -> string {match (value) {case None() => "option none"case Some(number) => "option some {number}"}}function result(value: Result<int, string>) -> string {match (value) {case Ok(number) => "result ok {number}"case Err(text) => "result error {text}"}}writeLine(describe(Reply.None()))writeLine(describe(Reply.Some(4)))writeLine(describe(Reply.Ok("yes")))writeLine(describe(Reply.Err(true)))writeLine(option(None()))writeLine(option(Some(5)))writeLine(result(Ok(6)))writeLine(result(Err("no")))
enum none
enum some 4
enum ok yes
enum error
option none
option some 5
result ok 6
result error no
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
enum noneenum some 4enum ok yesenum erroroption noneoption some 5result ok 6result error no
A unique constructor head projects its declared payload from a union
링크import std.io { writeLine }enum Left { Number(int) }enum Right { Text(string) }function describe(value: Left | Right) -> string {match (value) {case Number(number) => "{number + 1}"case Text(text) => text}}writeLine(describe(Left.Number(4)))writeLine(describe(Right.Text("right")))
5
right
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
5right
A typed pattern selects one nominal owner before matching a shared variant
링크import std.io { writeLine }enum Left { Shared(int) }enum Right { Shared(string) }function describe(value: Left | Right) -> string {match (value) {case left: Left => match (left) { case Shared(number) => "left {number}" }case right: Right => match (right) { case Shared(text) => "right {text}" }}}writeLine(describe(Left.Shared(3)))writeLine(describe(Right.Shared("R")))
left 3
right R
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
left 3right R
Typed narrowing distinguishes an enum Ok from a Result Ok
링크import std.io { writeLine }enum Reply { Ok(int) }function describe(value: Reply | Result<int, string>) -> string {match (value) {case reply: Reply => match (reply) { case Ok(number) => "reply {number}" }case result: Result<int, string> => match (result) {case Ok(number) => "result {number}"case Err(text) => text}}}let result: Result<int, string> = Ok(8)writeLine(describe(Reply.Ok(7)))writeLine(describe(result))
reply 7
result 8
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
reply 7result 8
Reject a shared bare constructor head before inspecting its payload
링크enum Left { Shared(int) }enum Right { Shared(int) }function describe(value: Left | Right) -> int {match (value) {case Shared(number) => numbercase _ => 0}}
표준 출력 없음.기대 결과
기대 결과
거절 단계 check. 종료 코드가 0이 아닙니다.
structures-ambiguous-constructor-pattern at
example.tpz:5:10
A prelude-spelled enum variant retains its declared payload arity
링크enum Reply { Ok(int, int) }function total(value: Reply) -> int {match (value) { case Ok(number) => number }}
표준 출력 없음.기대 결과
Newtype construction
링크Wrap one base value
링크newtype UserId = intlet user: UserId = UserId(7)
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
Newtype constructor argument type
A newtype constructor checks its single positional argument against the resolved base type and returns the newtype.
이유
The constructor creates a distinct nominal value from its declared base representation. Checking that representation prevents the wrapper from hiding an incompatible value.
Invalid newtype arguments
A newtype call with an argument count other than one or a spread argument produces TPZ5004. Named arguments follow the ordinary call argument rule and are rejected during parsing with TPZ2001.
이유
A newtype wraps one value and declares no field name for it. One positional argument expresses that relationship without invented labels or argument expansion.
Derive the existing protocols for a newtype
링크newtype Item derives Eq, Order, Show, JSON = intfunction jsonIdentity<T: JSON>(value: T) -> T { value }let value = Item(7)let same: bool = Eq.equals(value, value)let order: int = Order.compare(value, Item(8))let shown: string = Show.show(value)let retained: Item = jsonIdentity(value)
표준 출력 없음.기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
Call derived Eq and Show on a newtype
링크import std.io { writeLine }newtype Item derives Eq, Show = intlet value = Item(7)writeLine("{Eq.equals(value, Item(7))}")writeLine("{Eq.equals(value, Item(8))}")writeLine(Show.show(value))
true
false
Item(7)
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
truefalseItem(7)
Use the conditional derive binder on a newtype
링크newtype Box<T> derives<T: Eq> Eq<Box<T>> = Tlet left: Box<int> = Box(3)let right: Box<int> = Box(3)let same: bool = Eq.equals(left, right)
표준 출력 없음.기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
Require an explicit newtype conformance
링크newtype Item = intlet value = Item(7)let same = Eq.equals(value, value)
표준 출력 없음.기대 결과
Declaration type parameters
링크Give a generic record an expected type
링크record Box<T> { value: T }let box: Box<int> = Box { value: 3 }
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
Nominal type parameter lists
Record, enum, and newtype type parameters are comma-separated names inside angle brackets after the declaration name.
이유
Records, enums, and newtypes introduce type parameters in the same position and with the same delimiters. Readers do not need a separate binder notation for each declaration.
Expected types in generic record construction
이유
Records participate in the same nominal construction model as enums and newtypes.
Supply the complete nominal type through the expected context
Construct a generic record, enum, or newtype in a context that supplies the same nominal declaration and all its type arguments. The expected arguments may themselves be enclosing generic parameters. Field or payload values alone do not supply omitted nominal arguments; a missing matching context is a type-argument arity error (TPZ5022). The declaration origin is part of that match; the current record-context retargeting defect is an implementation limitation.
이유
A complete expected nominal type determines every argument, including arguments with no field or payload evidence. Matching its declaration keeps unrelated nominal types distinct.
Nested construction follows explicit expected-type propagation
A binding annotation, a declared argument type, a declared return or block-tail type, and parentheses can carry a complete nominal expectation to construction. Once a record is instantiated, its substituted declared field types provide expectations for nested constructions. A generic newtype uses the substituted base type from its matching expected newtype. Collection nesting follows the collection contextual-checking rule and preserves the matching nominal identity requirement.
이유
An instantiated field already has a substituted type. Passing it to nested construction lets that type information remain useful through grouping, calls, and returns.
Constructor type arguments come from nominal context
Explicit call type-argument lists belong to generic call targets. Nominal constructors do not contribute declaration parameters to that call-parameter list: a newtype or enum constructor call with explicit type arguments is rejected as a non-generic call (TPZ5512). Put the full nominal type in the surrounding annotation or other expected context instead. Record construction keeps its brace syntax; this rule makes no spacing-dependent promise about parser lookahead.
이유
Nominal construction obtains its type arguments from the expected nominal type. Keeping that rule across constructors avoids a second instantiation path through call syntax.
Construction examples and repairs
링크Missing a required field
링크record Point { x: int, y: int }let point = Point { x: 1 }
표준 출력 없음.error[TPZ5004]: record `Point` is missing field `y`
--> example.tpz:2:13
|
2 | let point = Point { x: 1 }
| ^^^^^^^^^^^^^^
example.tpz: 1 type diagnostic
기대 결과
관측한 단언 · 통과 · 5.21.3
종료 코드 1.
표준 출력 없음.
error[TPZ5004]: record `Point` is missing field `y`--> example.tpz:2:13|2 | let point = Point { x: 1 }| ^^^^^^^^^^^^^^example.tpz: 1 type diagnostic
- 통과 · expected nonzero; observed 1
- 통과 · stdout matches the authored expectation
- 통과 · checking TPZ5004; cause record `Point` is missing field `y`; primary location asserted; additional diagnostics allow
Supply the required field
링크record Point { x: int, y: int }let point = Point { x: 1, y: 2 }
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
A repeated field declaration
링크record Point {x: int,x: int,}
표준 출력 없음.error[TPZ5008]: record field `x` is declared twice in `Point`
--> example.tpz:3:3
|
3 | x: int,
| ^^^^^^
example.tpz: 1 type diagnostic
기대 결과
기대 결과
거절 단계 check. 종료 코드가 0이 아닙니다.
record field
xis declared twice inPointatexample.tpz:3:3
관측한 단언 · 통과 · 5.21.3
종료 코드 1.
표준 출력 없음.
error[TPZ5008]: record field `x` is declared twice in `Point`--> example.tpz:3:3|3 | x: int,| ^^^^^^example.tpz: 1 type diagnostic
- 통과 · expected nonzero; observed 1
- 통과 · stdout matches the authored expectation
- 통과 · checking TPZ5008; cause record field `x` is declared twice in `Point`; primary location asserted; additional diagnostics allow
Give each declared field its own name
링크record Point {x: int,y: int,}let point = Point { x: 1, y: 2 }
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
관측한 단언 · 통과 · 5.21.3
종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
표준 오류 출력 없음.
- 통과 · expected 0; observed 0
- 통과 · stdout matches the authored expectation
- 통과 · stderr matches the authored expectation
An extra newtype constructor argument
링크newtype UserId = intlet user = UserId(7, 8)
표준 출력 없음.error[TPZ5004]: newtype `UserId` constructor takes 1 argument (the `int` to wrap), found 2
--> example.tpz:2:12
|
2 | let user = UserId(7, 8)
| ^^^^^^^^^^^^
example.tpz: 1 type diagnostic
기대 결과
기대 결과
거절 단계 check. 종료 코드가 0이 아닙니다.
newtype
Userconstructor takes 1 argument atId example.tpz:2:12
관측한 단언 · 통과 · 5.21.3
종료 코드 1.
표준 출력 없음.
error[TPZ5004]: newtype `UserId` constructor takes 1 argument (the `int` to wrap), found 2--> example.tpz:2:12|2 | let user = UserId(7, 8)| ^^^^^^^^^^^^example.tpz: 1 type diagnostic
- 통과 · expected nonzero; observed 1
- 통과 · stdout matches the authored expectation
- 통과 · checking TPZ5004; cause newtype `UserId` constructor takes 1 argument; primary location asserted; additional diagnostics allow
Defaults run for each omitted field
링크import std.iofunction fallback() -> int {io.writeLine("default")7}record Sample { value: int = fallback() }let a = Sample {}let b = Sample { value: 9 }let c = Sample {}io.writeLine("{a.value}:{b.value}:{c.value}")
default
default
7:9:7
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
defaultdefault7:9:7
Reject a default of the wrong field type
링크record BadDefault { value: int = "bad" }let value = BadDefault {}
표준 출력 없음.기대 결과
Use a default of the declared field type
링크record BadDefault { value: int = 7 }let value = BadDefault {}
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
A spread precedes source-ordered replacements
링크import std.iofunction mark(label: string, value: int) -> int {io.writeLine(label)value}record Pair { x: int = mark("default-x", 1), y: int = mark("default-y", 2) }function seed() -> Pair {io.writeLine("seed")Pair { x: 10, y: 20 }}let updated = Pair { ...seed(), y: mark("y", 7), x: mark("x", 8) }let point = { x: 1, y: 2 }let moved = point { y: mark("structural-y", 3) }io.writeLine("{updated.x}:{updated.y}:{point.y}:{moved.y}")
seed
y
x
structural-y
8:7:2:3
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
seedyxstructural-y8:7:2:3
Reject value-update syntax on a nominal record
링크record Point { x: int }let point = Point { x: 1 }let moved = point { x: 2 }
표준 출력 없음.기대 결과
Use a named construction with a spread
링크record Point { x: int }let point = Point { x: 1 }let moved = Point { ...point, x: 2 }
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
Check an empty enum and a finite recursive enum construction
링크enum Empty {}enum Tree { Leaf(int), Branch(Array<Tree>) }let leaf: Tree = Tree.Leaf(3)let tree: Tree = Tree.Branch([leaf])
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
Reject a repeated variant in one enum
링크enum Choice { A, A }
표준 출력 없음.기대 결과
Check distinct enum variants
링크enum Choice { A, B }let value: Choice = Choice.B()
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
Annotations, arguments, returns and substituted record fields
링크record Box<T> { value: T }newtype Wrapped<T> = Tfunction make<T>(value: T) -> Box<T> { Box { value: value } }function wrap<T>(value: T) -> Wrapped<T> { Wrapped(value) }function consume(value: Box<int>) -> int { value.value }let nested: Box<Box<int>> = Box { value: Box { value: 3 } }let argument = consume(Box { value: 2 })let made: Box<string> = make("seven")let wrapped: Wrapped<int> = Wrapped(6)let genericWrapped: Wrapped<string> = wrap("value")
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
Fields do not infer a generic record specialization
링크record Box<T> { value: T }let box = Box { value: 1 }
표준 출력 없음.기대 결과
An annotation supplies the record specialization
링크record Box<T> { value: T }let box: Box<int> = Box { value: 1 }
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
A payload does not infer a generic newtype specialization
링크newtype Wrapped<T> = Tlet wrapped = Wrapped(1)
표준 출력 없음.기대 결과
An annotation supplies the newtype specialization
링크newtype Wrapped<T> = Tlet wrapped: Wrapped<int> = Wrapped(1)
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
Nominal parameters are not generic call parameters
링크newtype Wrapped<T> = Tlet wrapped: Wrapped<int> = Wrapped<int>(1)
표준 출력 없음.기대 결과
기대 결과
거절 단계 check. 종료 코드가 0이 아닙니다.
structures-nominal-call-type-arguments at
example.tpz:2:29
Put newtype arguments in the annotation
링크newtype Wrapped<T> = Tlet wrapped: Wrapped<int> = Wrapped(1)
example.tpz: types-ok (1 module)
example.tpz: resolve-ok (1 module)
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (1 module)example.tpz: resolve-ok (1 module)
A foreign expectation cannot change the constructor declaration
링크import models { Box as RemoteBox }record Box<T> { value: T }let wrong: RemoteBox<int> = Box { value: 1 }
표준 출력 없음.export record Box<T> { value: T }
기대 결과
Source-derived candidate: the checker can retarget the constructor before the origin guard. The intended TPZ5022 expectation is retained; no product execution receipt has been fabricated.
Use the constructor whose declaration matches the expectation
링크import models { Box as RemoteBox }record Box<T> { value: T }let wrong: RemoteBox<int> = RemoteBox { value: 1 }
example.tpz: types-ok (2 modules)
example.tpz: resolve-ok (2 modules)
export record Box<T> { value: T }
기대 결과
기대 결과
검사가 프로그램을 받아들입니다. 종료 코드 0.
example.tpz: types-ok (2 modules)example.tpz: resolve-ok (2 modules)
A structural update cannot repeat a field
링크let point = { x: 1 }let moved = point {x: 2,x: 3,}
표준 출력 없음.기대 결과
A later initializer cannot hide an incompatible earlier value
링크let point = { x: 1 }let moved = point {x: "bad",x: 2,}
표준 출력 없음.기대 결과
One explicit initializer can replace a copied field
링크import std.iorecord Point { x: int }let original = { x: 1 }let updated = original { x: 2 }let named = Point { x: 3 }let copied = Point { ...named, x: 4 }io.writeLine("{updated.x}:{original.x}:{copied.x}:{named.x}")
2:1:4:3
기대 결과
기대 결과
실행을 마칩니다. 종료 코드 0.
2:1:4:3
Related diagnostics
링크Explicit type arguments are not allowed here →