Kairo Functions, Methods, and Async Reference

​

func

[visibility] func <name>(<param>: <Type>, ...): <ReturnType> {
    // body
}

• At module scope, func is a free function.
• Inside a value, object, or contract, func is an instance method or requirement.
• Omitting the return type means the function returns no value.
• No overload resolution: names must be unique in their scope.
• No default parameter values in v0.1.

public func calculateTotal(order: Order): Money {
    return order.total
}

​

Instance method

• Value methods have an immutable this.
• Object methods have an identity-bearing this and may mutate var members.
• Contract methods are requirements: signature only, no body.
• Extension methods are deferred.

public object Customer {
    public var name: Text

    public func rename(newName: Text) {
        this.name = newName
    }
}

​

type func

[visibility] type func <name>(<param>: <Type>, ...): <ReturnType> {
    // body
}

• Must be declared inside a value or object.
• Has no this receiver.
• Called through the type name: TypeName.functionName(...).
• Kairo does not use static in v0.1.

public value EmailAddress {
    value: Text

    public type func create(value: Text): EmailAddress {
        return EmailAddress {
            value: value
        }
    }
}

​

init

[visibility] init(<param>: <Type>, ...) {
    // body
}

• Only allowed inside object. Values have no init.
• Exactly one primary init per object in v0.1.
• Required immutable members must be assigned before init completes.
• Cannot return a value.
• Constructor overloading, constructor delegation, and lifecycle hooks are deferred.

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

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

​

async func

[visibility] async func <name>(<param>: <Type>, ...): <ReturnType> {
    // body
}

• May appear on free functions, instance methods, type func, and contract requirements.
• Not allowed on init or type declarations.
• The language shape is frozen for v0.1; the async runtime is deferred.

public async func fetchCustomer(id: CustomerId): Customer {
    return await CustomerApi.get(id)
}

​

await

await <asyncCall>(...)

• Only valid inside async func.
• Does not unwrap Result<T, E>.
• Does not create hidden detached background work.
• Between suspension points, code runs in program order.

let customer = await fetchCustomer(customerId)

​

Local bindings

​

let

let <name>[: <Type>] = <expression>

• Immutable binding.
• Type inference is supported when the initializer type is obvious.

​

var

var <name>: <Type> = <expression>

• Mutable binding.
• Local var requires an explicit type in v0.1.

​

this

​

return

return <expression>
return

• Exits the current callable.
• Returned expression must be assignment-compatible with the declared return type.
• Functions with no declared return type must not return a value.

​

Related