@eagleoutice/flowr - v2.17.4
    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"
                    | "list"
                    | "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<ValueList, { 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"
                    | "list"
                    | "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<ValueList, { 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

    • knownStringsOf: function
    • Readonlyname: "NodeValue"
    • of: function
    • setOf: function
    • singleStringOf: function
    • Readonlysole: {
          (this: void, set: ValueSet<(...)[]> | undefined): Value | undefined;
          <
              T extends
                  | symbol
                  | "string"
                  | "number"
                  | "set"
                  | "list"
                  | "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<ValueList, { type: ... }>
              | Extract<ValueSet<(...)>, { type: ... }>
              | Extract<ValueNumber<(...)>, { type: ... }>
              | Extract<ValueString<(...)>, { type: ... }>
              | Extract<ValueLogical, { type: ... }>
              | Extract<ValueMissing, { type: ... }>
              | Extract<ValueFunctionDefinition, { type: ... }>
              | Extract<ValueNull, { type: ... }>
              | undefined;
      }

      The one value a set holds, undefined unless it holds exactly one, optionally of the given kind.

    • soleOf: function

      • The one value the node resolves to, undefined unless it is exactly one, optionally of the given kind.

        Type Parameters

        • OtherInfo
        • T extends
              | symbol
              | "string"
              | "number"
              | "set"
              | "list"
              | "vector"
              | "interval"
              | "logical"
              | "missing"
              | "function-definition"
              | "null"

        Parameters

        • this: void
        • id: Target
        • against: Against<OtherInfo>
        • Optionaltype: T
        • Optionaloverrides: Partial<ResolveInfo>

        Returns
            | Extract<{ type: symbol }, { type: T }>
            | Extract<{ type: symbol }, { type: T }>
            | Extract<ValueInterval<ValueNumber<(...)>>, { type: T }>
            | Extract<ValueVector<Lift<(...)>, Value>, { type: T }>
            | Extract<ValueList, { 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: function

      • The strings the node may hold, those of a vector of strings (c("a", "b")) included, undefined if it does not resolve to strings.

        Type Parameters

        • OtherInfo

        Parameters

        Returns string[] | undefined

    api

    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