effect-tea-persistent
    Preparing search index...

    Interface World

    Entities on the machine together, with one time and one process for all of them (decision 0131).

    interface World {
        advance: (duration: Input) => Effect<void>;
        create: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Program<T>,
            id: string,
            ...flags: Flagged<T>,
        ) => Effect<Member<T>>;
        deploy: <
            T extends
                Readonly<
                    {
                        flags: unknown;
                        inbound: unknown;
                        index: string;
                        internal: unknown;
                        key: string;
                        operation: Readonly<{ _tag: string }>;
                        parameter: object;
                        projection: unknown;
                        rejection: unknown;
                        sender: unknown;
                        services: unknown;
                        state: object;
                        topics?: Readonly<Record<string, Json>>;
                    },
                >,
        >(
            program: Program<T>,
        ) => Effect<void>;
        restart: Effect<void>;
    }
    Index
    advance create deploy restart
    advance: (duration: Input) => Effect<void>

    Time passes by duration for every entity of the world. Each timer due within it fires at its time, in the order of the times, and every mailbox it reaches is handled before the next one fires (decision 0187). At one time, a key fires again only with a due time later than the one it last fired with, or the test fails (decision 0266).

    create: <
        T extends
            Readonly<
                {
                    flags: unknown;
                    inbound: unknown;
                    index: string;
                    internal: unknown;
                    key: string;
                    operation: Readonly<{ _tag: string }>;
                    parameter: object;
                    projection: unknown;
                    rejection: unknown;
                    sender: unknown;
                    services: unknown;
                    state: object;
                    topics?: Readonly<Record<string, Json>>;
                },
            >,
    >(
        program: Program<T>,
        id: string,
        ...flags: Flagged<T>,
    ) => Effect<Member<T>>

    Creates an entity of program, which the world runs under its name from then on. It fails the test when the world runs another program under that name, as a second deploy of a name fails in the runtime (decision 0075). It fails the test too when the program's init rejects the flags: a test of a rejection calls init itself, which is pure, or creates from a runner, whose create is answered Rejected (decision 0182). The flags come last, and are left out where the program's flags are null (decision 0245).

    deploy: <
        T extends
            Readonly<
                {
                    flags: unknown;
                    inbound: unknown;
                    index: string;
                    internal: unknown;
                    key: string;
                    operation: Readonly<{ _tag: string }>;
                    parameter: object;
                    projection: unknown;
                    rejection: unknown;
                    sender: unknown;
                    services: unknown;
                    state: object;
                    topics?: Readonly<Record<string, Json>>;
                },
            >,
    >(
        program: Program<T>,
    ) => Effect<void>

    A deploy of a new version of a program: the process dies, and the program's entities are activated by it. A program that cannot run as written fails the test before the process dies (decision 0054).

    restart: Effect<void>

    The process dies after the last commit, and every entity is activated again from what was stored.

    Settings
    Member Visibility

    On This Page
    Properties