nupp.store

newKeyconstructor#

function newKey<T>(name: string?): Key<T>

Creates a key.

The type argument comes from the annotation at the declaration. A named key is registered for the runtime state's lifetime; an anonymous key is retained by nothing but its holders.

Type parameters

Arguments

Returns

Raises

• when the name is empty or already registered, before an id is used

newStoreconstructor#

function newStore(): Store

Creates an empty store.

Returns

Keyinterface#

interface Key<T>
    readonly id: integer
    readonly name: string?
end

A typed identity for one value in a nupp.store.Store.

id and name are all a key holds at runtime. _valueType is never present: it mentions T in both positions so that keys are invariant, which is what makes a wrong write through one a checker error rather than a silent widening.

Type parameters

Fields

id: integer

name: string?

KeySteptype#

type KeyStep = function(any, integer): (integer, string)

The step of nupp.store.registeredKeys.

Terminating on nil is the generic for's business, so the surface type promises what the loop delivers rather than what the last call returns.

Storerecord#

record Store
    get: function<T>(self: Store, key: Key<T>): T?
    set: function<T>(self: Store, key: Key<T>, value: T): nil
    remove: function<T>(self: Store, key: Key<T>): nil
    clear: function(self: Store): nil
    entries: function(
        borrows self: Store
    ): (function(Store, integer): (integer, string?, string), Store borrows (self), integer)
end

An independent typed bag indexed by keys.

Methods

get: function<T>(self: Store, key: Key<T>): T?

set: function<T>(self: Store, key: Key<T>, value: T): nil

remove: function<T>(self: Store, key: Key<T>): nil

clear: function(self: Store): nil

entries: function(
    borrows self: Store
): (function(Store, integer): (integer, string?, string), Store borrows (self), integer)

StoreSteptype#

type StoreStep = function(Store, integer): (integer, string?, string)

The step of Store.entries.

Terminating on nil is the generic for's business, so the surface type promises what the loop delivers rather than what the last call returns.

findKeyfunction#

function findKey(name: string): unknown

Finds a registered key by name.

The registry knows the name's id and nothing about its type, so the result is unknown and the caller casts to the Key<T> it claims.

Arguments

Returns

registeredKeysfunction#

function registeredKeys(): KeyStep, any, integer

Walks every registered name, ascending by id.

The walk allocates nothing: the step is one shared function and the control variable is the id it last reported. The registry itself is never handed out, so nothing the loop is given can be used to reach or change it. An anonymous key registers no name and is not walked.

Returns