Kairo Type Declarations: value, object, contract, enum

Reference for every type declaration form in Kairo v0.1: value, object, contract, and enum, plus the visibility modifiers and construction forms that go with them.

Visibility modifiers

Modifier	Scope
`public`	Visible outside the package
`internal`	Visible inside the same package (default)
`private`	Visible inside the declaring type or file

All declaration keywords accept a visibility modifier prefix.

`value`

Declares an immutable, identity-free type. Syntax

[visibility] value <Name> [: <Contract>, ...] {
    <memberName>: <Type>
    [type func <name>(...): <ReturnType> { ... }]
    [func <name>(...): <ReturnType> { ... }]
}

Rules

Value members must be value-like.
Members are immutable by default.
No init block; values are assembled with a field block.
May declare instance methods, type funcs, and conform to contracts.

Example

public value Money {
    amount: Decimal
    currency: Text
}

`object`

Declares an identity-bearing type. Syntax

[visibility] object <Name> [: <Contract>, ...] {
    <memberName>: <Type>
    var <memberName>: <Type>
    [init(<param>: <Type>, ...) { ... }]
    [func <name>(...): <ReturnType> { ... }]
    [type func <name>(...): <ReturnType> { ... }]
}

Rules

Members are immutable by default; use var for mutable members.
Required immutable members must be assigned in init.
Exactly one primary init in v0.1; no constructor overloading.
May declare instance methods, type funcs, and conform to contracts.

Example

public object Customer {
    public id: CustomerId
    public var name: Text

    public init(id: CustomerId, name: Text) {
        this.id = id
        this.name = name
    }
}

`contract`

Declares a capability contract that types can conform to. Syntax

[visibility] contract <Name>[<TypeParam[: <Contract>], ...>] {
    <memberName>: <Type>
    var <memberName>: <Type>
    func <name>(...): <ReturnType>
}

Rules

Contracts declare requirements only. No stored fields, no init, no method bodies, no type func.
May require methods, read-only properties, and read-write properties.
May be generic and may declare contract constraints on type parameters.
Enum conformance, default implementations, and generic contract conformance are deferred.

Example

public contract Named {
    name: Text
}

public contract Formatter<T: Displayable> {
    func format(value: T): Text
}

Contract conformance

Declares that a value or object satisfies one or more contracts. Syntax

[visibility] value <Name> : <ContractA>, <ContractB> { ... }
[visibility] object <Name> : <ContractA>, <ContractB> { ... }

Rules

Conformance is always explicit.
Forge verifies every required member is present with a matching signature.
Each contract in the list must resolve to a contract type.

Example

public object Customer : Named {
    public id: CustomerId
    public var name: Text

    public init(id: CustomerId, name: Text) {
        this.id = id
        this.name = name
    }
}

`enum`

Declares a finite, named set of cases. Syntax

[visibility] enum <Name> {
    <CaseA>
    <CaseB>
}

Rules

Case names must be unique within the enum.
Enum cases are PascalCase.
Case payloads (associated values) are deferred in v0.1.
match on enum cases follows the exhaustiveness rules described in Operators.

Example

public enum OrderStatus {
    Draft
    Submitted
    Paid
    Cancelled
}

Members

Member field

<memberName>: <Type>        // immutable
var <memberName>: <Type>    // mutable

Value members must be value-like. Object members may store any type. Mutable members require var.

Computed property

<propertyName>: <Type> {
    get { ... }
    set(value: <Type>) { ... }
}

get is required for readable properties. set accepts a single value parameter matching the property type. Kairo does not auto-generate getters or setters in v0.1.

Construction

Value construction

<TypeName> {
    <fieldName>: <expression>
    ...
}

All required fields must be supplied exactly once.

let total = Money {
    amount: 125.50
    currency: "AUD"
}

Object construction

<TypeName>(<paramName>: <expression>, ...)

Arguments must be named. There is no positional-only form for object construction in v0.1.

let customer = Customer(
    id: customerId,
    name: "Pete"
)

Types (language guide)

The value/object model in prose.

Command Catalog

Every construct in a scannable table.

Language Reference

Forge CLI

Pulse Runtime

Kairo Type Declarations: value, object, contract, enum

Visibility modifiers

`value`

`object`

`contract`

Contract conformance

`enum`

Members

Member field

Computed property

Construction

Value construction

Object construction

Types (language guide)

Command Catalog

​Visibility modifiers

​value

​object

​contract

​Contract conformance

​enum

​Members

​Member field

​Computed property

​Construction

​Value construction

​Object construction

​Related

Types (language guide)

Command Catalog

Visibility modifiers

`value`

`object`

`contract`

Contract conformance

`enum`

Members

Member field

Computed property

Construction

Value construction

Object construction

Related