@eagleoutice/flowr - v2.15.8
    Preparing search index...

    Variable NodeValueConst

    NodeValue: {
        knownStringsOf<OtherInfo>(
            this: void,
            id: Target,
            against: Against<OtherInfo>,
            overrides?: Partial<ResolveInfo>,
        ): string[];
        name: "NodeValue";
        of<OtherInfo>(
            this: void,
            id: Target,
            against: Against<OtherInfo>,
            overrides?: Partial<ResolveInfo>,
        ): ResolveResult;
        setOf<OtherInfo>(
            this: void,
            id: Target,
            against: Against<OtherInfo>,
            overrides?: Partial<ResolveInfo>,
        ): ValueSet<Value[]> | undefined;
        singleStringOf<OtherInfo>(
            this: void,
            id: Target,
            against: Against<OtherInfo>,
            overrides?: Partial<ResolveInfo>,
        ): string | undefined;
        sole: {
            (this: void, set: ValueSet<(...)[]> | undefined): Value | undefined;
            <
                T extends
                    | symbol
                    | "string"
                    | "number"
                    | "set"
                    | "vector"
                    | "interval"
                    | "logical"
                    | "missing"
                    | "function-definition"
                    | "null",
            >(
                this: void,
                set: ValueSet<(...)[]> | undefined,
                type: T,
            ):
                | Extract<{ type: ... }, { type: ... }>
                | Extract<{ type: ... }, { type: ... }>
                | Extract<ValueInterval<(...)>, { type: ... }>
                | Extract<ValueVector<(...), (...)>, { type: ... }>
                | Extract<ValueSet<(...)>, { type: ... }>
                | Extract<ValueNumber<(...)>, { type: ... }>
                | Extract<ValueString<(...)>, { type: ... }>
                | Extract<ValueLogical, { type: ... }>
                | Extract<ValueMissing, { type: ... }>
                | Extract<ValueFunctionDefinition, { type: ... }>
                | Extract<ValueNull, { type: ... }>
                | undefined;
        };
        soleOf<
            OtherInfo,
            T extends
            
                    | symbol
                    | "string"
                    | "number"
                    | "set"
                    | "vector"
                    | "interval"
                    | "logical"
                    | "missing"
                    | "function-definition"
                    | "null",
        >(
            this: void,
            id: Target,
            against: Against<OtherInfo>,
            type?: T,
            overrides?: Partial<ResolveInfo>,
        ):
            | Extract<{ type: symbol }, { type: T }>
            | Extract<{ type: symbol }, { type: T }>
            | Extract<ValueInterval<ValueNumber<(...)>>, { type: T }>
            | Extract<ValueVector<Lift<(...)>, Value>, { type: T }>
            | Extract<ValueSet<Lift<(...)>>, { type: T }>
            | Extract<ValueNumber<Lift<(...)>>, { type: T }>
            | Extract<ValueString<Lift<(...)>>, { type: T }>
            | Extract<ValueLogical, { type: T }>
            | Extract<ValueMissing, { type: T }>
            | Extract<ValueFunctionDefinition, { type: T }>
            | Extract<ValueNull, { type: T }>
            | undefined;
        stringsOf<OtherInfo>(
            this: void,
            id: Target,
            against: Against<OtherInfo>,
            overrides?: Partial<ResolveInfo>,
        ): string[] | undefined;
    } = ...

    The value(s) a node may hold. Every entry point resolves against either the state the current processor sees or a ResolveInfo, so a finished analysis asks the same questions in the same words, and takes overrides for the cases that deviate (e.g. another environment).

    This is constant propagation over the dataflow graph, not abstract interpretation: it follows definitions to constants and gives up wherever a value is not statically pinned down, with no fixpoint and no widening. Anything needing an abstract state lives in src/abstract-interpretation/.

    Type Declaration

    NodeValue.of(id, data);                          // during processing
    NodeValue.setOf(id, await Resolve.infoOf(analyzer)); // on a finished analysis
    NodeValue.sole(NodeValue.setOf(id, data));       // the single value, if there is exactly one

    Settings
    Member Visibility