Types and traits · Konjure

A type owns typed fields and methods. A trait describes methods a value must provide. Neither schedules work: attach a type value to an entity and use a system when it needs to run over time.

Make a type value

The fixture prints 4 and then Some(9): it constructs a nominal type value, then reads a list through an explicit optional value.

main.kj⌘ / Ctrl + Enter

Loading the language runtime…

Output 0

No output.

type Name { field: T; func method() -> T { ... } } declares a nominal record. Fields may have defaults. A constructor may omit a defaulted field, but must supply every field without a default; unknown fields and incompatible values are compile errors. Two types with the same fields still have different types. Fields are public.

Methods use the implicit self receiver; do not list it as a parameter. A method that changes self needs a receiver rooted in a mutable binding. The compiler checks every type and method body, including unused ones.

State a behavior contract

trait Readable { func read() -> f32; } states a callable contract. impl Readable for Gauge must provide every required method with exactly that signature. A trait-typed value exposes the trait methods, not arbitrary fields of its implementing type. Type inheritance, associated types, generic bounds, and derivation are not implemented.

Store and pass functions

Write a function type as func(f32) -> f32. A function value can be assigned to a binding, passed to another function, returned, or stored in a typed list or type field. Calls check the same signature in every position.

main.kj⌘ / Ctrl + Enter

func twice(value: Number) -> Res[Number, DataError] {
  ret Ok((value * 2)?);
}

func sine(value: Number) -> Res[Number, DataError] {
  ret value.sin();
}

func map(
  values: List[Number],
  transform: func(Number) -> Res[Number, DataError],
) -> Res[List[Number], DataError] {
  let mut mapped: List[Number] = [];
  for value in values {
    mapped = mapped.append(transform(value)?);
  }
  ret Ok(mapped);
}

func choose(transform: func(Number) -> Res[Number, DataError]) -> func(Number) -> Res[Number, DataError] {
  ret transform;
}

type Meter {
  transform: func(Number) -> Res[Number, DataError] = sine;
}

func report(callback: func(Str) -> Unit) -> Unit {
  callback("from a callback");
}

let alias: func(Number) -> Res[Number, DataError] = sine;
let transform = choose(alias);
let mapped = map([0, 1], transform)?;
let meter = Meter { transform: twice };
let operations: List[func(Number) -> Res[Number, DataError]] = [twice, sine];

print(mapped.len());
print(meter.transform(3)?);
print(alias(0)?);
print(operations[0]?(3)?);
report(print);

Loading the language runtime…

Output 0

No output.

Reading a nonmutating method as a value captures a copy of its receiver. Capturing a method that mutates an ordinary type is rejected: use bind[T](entity).method for a callback that updates an entity’s live component.

Specialize ECS helpers

Choose the component type before storing an ECS helper: get[Counter] is a function value; get[Counter](entity) calls it immediately. The same rule applies to has, query, and bind.

Value	Function type
`get[Counter]`	`func(Entity) -> Counter`
`has[Counter]`	`func(Entity) -> Bool`
`query[Counter]`	`func() -> List[Entity]`
`bind[Counter]`	`func(Entity) -> ComponentReference[Counter]`

main.kj⌘ / Ctrl + Enter

type Counter {
  value: Number = 3;

func advance() -> Res[Unit, DataError] {
    self.value = (self.value + 1)?;
    ret Ok(());
  }
}

type Helpers {
  read: func(Entity) -> Counter = get[Counter];
  exists: func(Entity) -> Bool = has[Counter];
  all: func() -> List[Entity] = query[Counter];
  reference: func(Entity) -> ComponentReference[Counter] = bind[Counter];
}

func read_value(read: func(Entity) -> Counter, entity: Entity) -> Number {
  ret read(entity).value;
}

func attach(
  reference: func(Entity) -> ComponentReference[Counter],
  entity: Entity,
) -> ComponentReference[Counter] {
  ret reference(entity);
}

let item = spawn(Counter {});
let helpers = Helpers {};
let read = get[Counter];
let exists = has[Counter];
let all = query[Counter];
let reference = bind[Counter];

print(read(item).value);
print(exists(item));
print(all().len());

let counter = attach(reference, item);
counter.advance()?;
print(read_value(read, item));

helpers.reference(item).advance()?;
print(helpers.read(item).value);
print(helpers.exists(item));
print(helpers.all().len());

Loading the language runtime…

Output 0

No output.

ComponentReference[Counter] stores an entity/component identity; calling its bound methods resolves the current component. Function parameters, return values, and fields use explicit types; local bindings infer a fixed type from their initializer. Imported type identity is nominal: models.Point is distinct from a local Point.