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

    Interface DefaultBuiltInProcessorConfiguration

    Semantics of a built-in that hold no matter which processor handles the call.

    interface DefaultBuiltInProcessorConfiguration {
        alternativeArgsFrom?: number;
        ambient?: AmbientStateAccess | readonly AmbientStateAccess[];
        cfg?: ExitPointType;
        dispatches?: string[];
        frame?: number;
        hasUnknownSideEffects?: boolean | LinkTo<string | RegExp>;
        keepArgumentOut?: boolean;
        keepEnvironment?: boolean;
        markArgsAsMasked?: readonly number[] | NseArguments;
        markArgsAsNSE?: readonly number[] | NseArguments;
        namesIn?: readonly string[];
        props?: number;
        readAllArguments?: boolean;
        readsDots?: boolean;
        readsFrame?: boolean;
        scope?: AmbientScope;
        sig?: FnSig;
        signals?: readonly string[];
        tags?: SemanticCallTags;
        treatAsFnCall?: Record<BrandedIdentifier, readonly BrandedIdentifier[]>;
        useAsProcessor?: BuiltInProcName;
    }

    Hierarchy (View Summary)

    Index
    alternativeArgsFrom?: number

    see ProcessKnownFunctionCallInput#alternativeArgsFrom

    ambient?: AmbientStateAccess | readonly AmbientStateAccess[]

    how the call reads or writes global state like the graphics parameters, the options, or files, see AmbientStateAccess

    dispatches?: string[]

    the generics the call may dispatch to on (parts of) its arguments, like as.character for paste or format for the columns print shows of a data frame; any method of them may run

    frame?: number

    What this call lets the function around it reach about its own formals without naming one of them, e.g. match.call() (ArgProp.Nse) or nargs() (ArgProp.Presence); see reflectiveRolesOf.

    hasUnknownSideEffects?: boolean | LinkTo<string | RegExp>
    keepArgumentOut?: boolean

    Propagate the out references produced by the arguments instead of dropping them. Set this for functions that are transparent about their arguments, like (.

    keepEnvironment?: boolean

    keep the environment on the call vertex, for a later pass to look names up in

    markArgsAsMasked?: readonly number[] | NseArguments

    Mark the given arguments as evaluated in a data mask, like subset: their symbols may name columns of the data instead of variables, while everything else in them is evaluated in the caller's frame as usual.

    markArgsAsNSE?: readonly number[] | NseArguments

    Mark the given arguments as non-standard-evaluated, like quote.

    namesIn?: readonly string[]

    The formals whose arguments name variables the call reads by their string value, like save("x", list = v): a string literal anywhere, any other value except in ..., where a symbol is the variable itself.

    props?: number

    the bitfield of CallProp

    readAllArguments?: boolean
    readsDots?: boolean

    the call reads the dots of the function it is called in, like ...elt(2)

    readsFrame?: boolean

    without arguments, the result is the frame the call runs in, like environment(), so within a function it reads every binding of the frame

    scope?: AmbientScope

    the call changes that state for a scope only, see AmbientScope

    sig?: FnSig

    the parameters and what each of their arguments is used for

    signals?: readonly string[]

    The condition classes a call signals when every argument it is handed is a constant, like simpleError, error, and condition for stop("x").

    the array of SemanticCallTag

    treatAsFnCall?: Record<BrandedIdentifier, readonly BrandedIdentifier[]>

    record mapping the actual function name called to the arguments that should be treated as function calls

    useAsProcessor?: BuiltInProcName

    Name that should be used for the origin (useful when needing to differentiate between functions like 'return' that use the default builtin processor)