Variable Identifier

Type Declaration

• accessesInternal: function

  • accessesInternal(this: void, id: Identifier | undefined): boolean | undefined

    Check if the identifier accesses internal objects (:::), undefined if it says nothing about it.

    Parameters

    • this: void
    • id: Identifier | undefined

    Returns boolean | undefined

• dotdotdot: function

  • dotdotdot(this: void): BrandedIdentifier

    Special identifier for the ... argument

    Parameters

    • this: void

    Returns BrandedIdentifier

• from: function

  • from(
        this: void,
        arr:
            | [BrandedIdentifier, BrandedNamespace]
            | [BrandedIdentifier, BrandedNamespace, boolean],
    ): Identifier

    Fast-path factory: returns the tuple as-is with no allocation or runtime checks. Use for static built-in config entries where name is a compile-time constant with no backticks.

    Parameters

    • this: void
    • arr:
          | [BrandedIdentifier, BrandedNamespace]
          | [BrandedIdentifier, BrandedNamespace, boolean]

    Returns Identifier

    Example

    Identifier.from(['map', 'purrr'])       // ['map', 'purrr']
    Identifier.from(['map', 'purrr', true]) // ['map', 'purrr', true]
    Copy

• fromAll: function

  • fromAll(
        this: void,
        namespace: BrandedNamespace,
        names: BrandedIdentifier[],
    ): Identifier[]

    The same fast path for many names of one package: the given array of names is cast in place, so the literal you pass is the only array involved.

    Parameters

    • this: void
    • namespace: BrandedNamespace
    • names: BrandedIdentifier[]

    Returns Identifier[]

    Example

    Identifier.fromAll('purrr', ['map', 'walk']) // [['map', 'purrr'], ['walk', 'purrr']]
    Copy

• fromAllIn: function

  • fromAllIn(
        this: void,
        namespaces: readonly BrandedNamespace[],
        names: readonly BrandedIdentifier[],
    ): Identifier[]

    The names as every one of the given packages exports them, for a function one package owns and others re-export unchanged (dplyr::%>% is magrittr::%>%).

    Parameters

    • this: void
    • namespaces: readonly BrandedNamespace[]
    • names: readonly BrandedIdentifier[]

    Returns Identifier[]

    Example

    Identifier.fromAllIn(['magrittr', 'dplyr'], ['%>%']) // [['%>%', 'magrittr'], ['%>%', 'dplyr']]
    Copy

• ReadonlygetName: Accessor<Identifier, BrandedIdentifier>

  Get the name part of the identifier, undefined if there is no identifier.

• getNamespace: function

  • getNamespace(
        this: void,
        id: Identifier | undefined,
    ): BrandedNamespace | undefined

    Get the namespace part of the identifier, undefined if there is none (or no identifier).

    Parameters

    • this: void
    • id: Identifier | undefined

    Returns BrandedNamespace | undefined

• is: function

  • is(this: void, id: unknown): id is Identifier

    Verify whether an unknown element has a valid identifier shape!

    Parameters

    • this: void
    • id: unknown

    Returns id is Identifier

• isDotDotDotAccess: function

  • isDotDotDotAccess(this: void, id: Identifier): boolean

    Check if the identifier is the special ... argument / or one of its accesses like ..1, ..2, etc. This always returns false for namespaced identifiers.

    Parameters

    • this: void
    • id: Identifier

    Returns boolean

• make: function

  • make(
        this: void,
        name: BrandedIdentifier,
        namespace?: BrandedNamespace,
        internal?: boolean,
    ): Identifier

    Creates an identifier. Strips surrounding backticks from the name. Prefer Identifier.from for static config entries where namespace is always present and name has no backticks.

    Parameters

    • this: void
    • name: BrandedIdentifier
    • Optionalnamespace: BrandedNamespace
    • internal: boolean = false

    Returns Identifier

• mapName: function

  • mapName(
        this: void,
        id: Identifier,
        fn: (name: BrandedIdentifier) => BrandedIdentifier,
    ): Identifier

    Functor over the name of the identifier

    Parameters

    • this: void
    • id: Identifier
    • fn: (name: BrandedIdentifier) => BrandedIdentifier

    Returns Identifier

• mapNamespace: function

  • mapNamespace(
        this: void,
        id: Identifier,
        fn: (ns: BrandedNamespace) => BrandedNamespace,
    ): Identifier

    Functor over the namespace of the identifier

    Parameters

    • this: void
    • id: Identifier
    • fn: (ns: BrandedNamespace) => BrandedNamespace

    Returns Identifier

• matches: function

  • matches(this: void, id: Identifier, target: Identifier, s3?: boolean): boolean

    Check if two identifiers match. This differs from eq! If the first identifier is not namespaced, it will match any namespace! If we search for S3 methods (s3=true), the target may have an additional suffix after a dot. If the first identifier is internal, it will match any target (internal or not).

    Parameters

    • this: void
    • id: Identifier
    • target: Identifier
    • s3: boolean = false

    Returns boolean

• Readonlyname: "Identifier"

• parse: function

  • parse(this: void, str: string): Identifier

    Parse an identifier from its string representation, Please note, that in R if one writes "pkg::a" this refers to a symbol named pkg::a and NOT to the namespaced identifier a in package pkg. In this scenario, see Identifier.make instead.

    Parameters

    • this: void
    • str: string

    Returns Identifier

• quote: function

  • quote(this: void, text: string): string

    The text as a regex matches it literally: [, $ and . name functions in R, they are not pattern syntax.

    Parameters

    • this: void
    • text: string

    Returns string

• regex: function

  • regex(this: void, ...identifiers: readonly Identifier[]): RegExp

    Helper to create a regular expression that matches against an array of Identifier values. If both the passed identifier and the matched identifier are namespaced, their namespaces are expected to match. If either is not namespaced, the namespace is ignored on both.

    Parameters

    • this: void
    • ...identifiers: readonly Identifier[]

    Returns RegExp

• toArray: function

  • toArray(
        this: void,
        id: Identifier,
    ): [BrandedIdentifier, BrandedNamespace | undefined, boolean | undefined]

    Convert the identifier to its array representation

    Parameters

    • this: void
    • id: Identifier

    Returns [BrandedIdentifier, BrandedNamespace | undefined, boolean | undefined]

• toQualified: function

  • toQualified(
        this: void,
        origins: readonly Origin[] | undefined,
        name?: Identifier,
        qualifyBaseR?: boolean,
    ): Identifier | undefined

    The package-qualified identifier of a call, resolved in order of decreasing certainty:

    1. a package export the origins resolve to (map() with purrr loaded yields purrr::map),
    2. an already-namespaced name returned unchanged (an explicit pkg::fn call),
    3. with qualifyBaseR, a bare base-R call qualified from its exporting package via baseRExportOwner (sd yields stats::sd), needing no loaded database or graph edge and skipped when the call resolves to a user definition, so a local sd() stays bare.

    Returns undefined when none apply. Steps 2 and 3 need the call's name.

    Parameters

    • this: void
    • origins: readonly Origin[] | undefined

      the origins of the call to qualify

    • Optionalname: Identifier

      the name the call was written with, needed by steps 2 and 3

    • qualifyBaseR: boolean = true

      whether to also qualify a bare base-R call from its exporting package (default true)

    Returns Identifier | undefined

    See

    Dataflow.qualify - the compact form, if you have the call's id and its graph

• ReadonlytoString: Accessor<Identifier, string>

  Convert the identifier to a valid R string representation, this will properly quote namespaces that contain :: to avoid confusion.

  Example

  Identifier.toString('a') // 'a'
  Identifier.toString(['a', 'pkg']) // 'pkg::a'
  Identifier.toString(['a', 'pkg:::internal', true]) // '"pkg:::internal":::a'
  Copy

• Readonlyview: Accessor<Identifier, IdentifierView>

  Wraps the identifier in an view offering property access (id.name, id.namespace) and methods. The view does not copy anything; see IdentifierView for when to use it.