Capabilities

All categories

Names and Identifiers

20 fully8 partially2 not

Recognizing the names an R program uses and resolving them to definitions.

Consider the following R code:

"f" <- function(x) { get("x") } 
`y x` <- 2
print(`y x` + f(3))

Identifiers of interest are:

• The symbols x (Normal), f (Quoted), and `y x` (Escaped).
• The function calls <-, function, {, get, +, and print (Calls, all given with Normal). Especially { is identified as a Grouping of the Function Definitions' body.
• The quoted name created by a function call get (Created).

Besides the parameter x, which is resolved in its Lexicographic Scope, the other identifiers are resolved in the Global Scope.

flowchart LR
    10["`**function** (L. 1)
*RFunctionDefinition*`"]

subgraph "flow-10" ["function(x) #123; get(#34;x#34;) #125; (L. 1)"]
    1["`**x** (L. 1)
*RSymbol*`"]
    8-get-name(["`**#34;x#34;** (L. 1)
*RSymbol*`"])
    8[["`base#58;#58;**get** (L. 1)
*RFunctionCall*`"]]
    built-in:get["`Built-In:
get`"]
    style built-in:get stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    9[["`base#58;#58;**#123;**
*RExpressionList*`"]]
    built-in:_["`Built-In:
#123;`"]
    style built-in:_ stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
end
    0["`**#34;f#34;** (L. 1)
*RString*`"]
    11[["`base#58;#58;**#60;#45;** (L. 1)
*RBinaryOp*`"]]
    built-in:_-["`Built-In:
#60;#45;`"]
    style built-in:_- stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    13{{"`**2** (L. 2)
*RNumber*`"}}
    12["`**#96;y x#96;** (L. 2)
*RSymbol*`"]
    14[["`base#58;#58;**#60;#45;** (L. 2)
*RBinaryOp*`"]]
    16(["`**#96;y x#96;** (L. 3)
*RSymbol*`"])
    18{{"`**3** (L. 3)
*RNumber*`"}}
    20[["`**f** (L. 3)
*RFunctionCall*`"]]
    21[["`base#58;#58;**#43;** (L. 3)
*RBinaryOp*`"]]
    built-in:_["`Built-In:
#43;`"]
    style built-in:_ stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    23[["`base#58;#58;**print** (L. 3)
*RFunctionCall*`"]]
    built-in:print["`Built-In:
print`"]
    style built-in:print stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    1 -->|"def-by-on-call"| 18
    8-get-name -->|"reads"| 1
    8 -->|"reads, returns, arg"| 8-get-name
    8 -.->|"reads, calls"| built-in:get
    linkStyle 3 stroke:gray;
    9 -->|"returns, arg"| 8
    9 -.->|"reads, calls"| built-in:_
    linkStyle 5 stroke:gray;
10 -.-|function| flow-10

    0 -->|"defined-by, flow"| 11
    0 -->|"defined-by"| 10
    11 -->|"reads, arg"| 10
    11 -->|"returns, arg"| 0
    11 -.->|"reads, calls"| built-in:_-
    linkStyle 11 stroke:gray;
    12 -->|"defined-by, flow"| 14
    12 -->|"defined-by"| 13
    14 -->|"reads, arg"| 13
    14 -->|"returns, arg"| 12
    14 -.->|"reads, calls"| built-in:_-
    linkStyle 16 stroke:gray;
    16 -->|"reads"| 12
    18 -->|"def-on-call"| 1
    20 -->|"reads, arg"| 18
    20 -->|"reads"| 0
    20 -->|"returns"| 8
    20 -->|"calls"| 10
    21 -->|"reads, arg"| 16
    21 -->|"reads, arg"| 20
    21 -.->|"reads, calls"| built-in:_
    linkStyle 25 stroke:gray;
    23 -->|"reads, returns, arg"| 21
    23 -.->|"reads, calls"| built-in:print
    linkStyle 27 stroke:gray;

"f" <- function(x) { get("x") } 
`y x` <- 2
print(`y x` + f(3))

• #Form
  5 children500

  • #Normal

    signature tests

    Simple Symbol, simple variable, a named formal alone

    Recognize symbol uses like a, plot, ... (i.e., "normal variables or function calls").

    Advanced RBindingsR DefinitionIdentifiers

  • #Quoted

    signature tests

    'f'(), With Quotes and Namespace, Assign to Given String

    Recognize "a", 'plot', ... R lets a name be quoted so it may hold spaces and the like, but only where it is defined; reaching it as a variable needs get or backticks.

    Advanced RNon-Syntactic Names

    example

    "my fn" <- function(x) x
    `my fn`(3)
    get("my fn")(3)

  • #Escaped

    signature tests

    non-ASCII escaped names survive, one distractor, without distractors

    Recognize `a`, `plot`, ...

    Advanced RNon-Syntactic Names

    example

    `my var` <- 1
    `my var` + 1

  • #Created

    signature tests

    get with an unresolvable name drops the definition it reads, get reads the definition of the name it resolves to, exists with the name in a variable

    Recognize functions that treat a string argument as the identifier it names, such as get, get0, mget, exists, match.fun, and assign. A name only known at runtime (get(Sys.getenv("V"))) names no identifier we could link.

    R DefinitionIdentifiers

    example

    x <- 1
    r <- get("x")
    print(r)

  • #Resolved Name

    signature tests

    get resolves x from custom env and e is read, get without envir resolves from global scope, get takes envir as its third formal, after pos

    Recognize a name resolved to a constant string and follow it like a written-out one. Covers literals, variables, and paste0/paste/file.path folded over constants.

    R DefinitionIdentifiers

    example

    nm <- paste0("x", 1)
    assign(nm, 42)
    get(nm)

• #Resolution

  signature tests

  unresolved get is reached-but-unknown, not dropped, higher-order fn, with alias chain

  25 children1582

  • #Global Scope

    signature tests

    Same variables, falls back to the global frame, a stand-in frame that held nothing passes the write on

    For example, tracking a big table of current identifier bindings

    R DefinitionGlobal environment

    example

    x <- 1
    f <- function() x
    f()

  • #Lexicographic Scope

    signature tests

    Same variables, Different variables, a stand-in frame binds what its lexical frame held

    For example, support function definition scopes

    R DefinitionLexical environment

    example

    f <- function() {
      y <- 1
      g <- function() y
      g()
    }
    f()

  • #Closures

    signature tests

    Calling a function which returns another, double nested functions, Must include function shell on call

    Two closures from the same factory keep independent state in R. A <<- in one is over-approximated as reaching the other.

    Advanced RFunction factoriesR DefinitionScope of variables

    example

    counter <- function() {
      i <- 0
      function() {
        i <<- i + 1
        i
      }
    }
    c1 <- counter()
    c2 <- counter()
    c1()
    c1()
    r <- c2()
    print(r)

  • #Closure Capture

    Handle ordinary function-factory capture. A closure sees later writes to its enclosing environment, including from a sibling closure.

    Advanced RFunction factoriesR DefinitionScope of variables

    example

    make <- function() {
      x <- 1
      list(get = function() x, set = function(v) x <<- v)
    }
    o <- make()
    o$set(5)
    r <- o$get()
    print(r)

  • #Dynamic Environment Resolution

    signature tests

    new.env() call carries NewEnv origin, nested: ls(e) resolves the custom env, assign to .GlobalEnv falls through to global

    For example, using new.env and friends. Covers new.env, assign/get/local with envir=, e$x, attach, with, and env-variable aliasing.

    R DefinitionEnvironment objects

    example

    e <- new.env()
    assign("x", 3, envir = e)
    get("x", envir = e) + e$x

    8 children440

    • #Environment in Control Flow

      signature tests

      for-loop populates env with dynamic keys: e read in body and after loop, parallel accumulation in two envs inside for-loop: reads isolated per..., assign in while-loop to custom env: e read in body, val not in global...

      Track environment assignments and reads across branches and loop bodies, a key built at run time such as paste0("k", i) included.

    • #Environment Parent

      signature tests

      a free name reached through a custom env is linked on call only, so w..., new.env(parent=NULL): same as emptyenv(), assign does not leak, new.env() without parent uses default (parent.frame()), tracked normally

      Specifying a parent for a newly-created environment from a dynamic or unknown expression (new.env(parent = f())). Such a parent falls back to the default (parent.frame()) instead of resolving.

    • #Environment Parent (Tracked)

      Specifying a parent for a newly-created environment from a tracked environment variable or a constant (new.env(parent = e), new.env(parent = emptyenv())).

    • #Environment Alias

      signature tests

      an assign to the original after the alias is reflected through it, alias of alias: double indirection still resolves x, alias does not see assigns made to original env AFTER alias was created

      Aliasing a tracked environment variable (alias <- e). An assign to the original variable made AFTER the alias is not reflected through the alias.

    • #Environment Alias Read

      Reading through an aliased tracked environment variable (alias <- e). Every assign made up to the alias is visible through it.

    • #With

      signature tests

      with(e, x): x resolves from envState, e is read, with untracked env falls through to default handling, with() scoping: y assigned inside with body is not in outer scope

      Evaluating an expression inside a named environment with with(data, expr). Reads of names the tracked env defines resolve, including through a computed data argument or a nested call.

    • #Parent Frame

      Reading via parent.frame()$name, and a write escaping through eval.parent(quote(name <- value)). Works only one call away; storing the frame first drops the binding.

      Advanced RCall stacks

    • #Dynamic Variable Removal

      signature tests

      rm(list=ls()) clears the whole environment, a shadowed ls does not clear the environment, a conditional rm only maybe removes the variable

      Support for rm(list=..., envir=sys.frame(N)) removing variables from a specific call frame. Currently handles negative and zero offsets from within depth-1 functions.

  • #Environment Sharing

    signature tests

    multiple assigns to same env all read e, attach(e) injects env contents into scope, local with custom env: x not in global scope

    Handling side-effects through environments, which act as reference types and are not copied when modified. A write through a parameter is kept as an unknown side effect of the call; see Environment Alias and Side-Effects in Function Call.

    R DefinitionEnvironment objectsAdvanced REnvironments

    example

    e <- new.env()
    assign("x", 42, envir = e)
    print(get("x", envir = e))

  • #Search Type

    signature tests

    Locally without distracting elements

    Separating the resolution for functions and symbols.

    c <- 1
    c(c, 2)

  • #Search Path

    signature tests

    Link usually, Link with variable, No dependencies set

    Handling R's search path. Attached packages sit below .GlobalEnv, so a global binding shadows an export.

    library(dplyr)
    filter <- function(...) "mine"
    filter(1)

  • #Dynamic Search Path

    signature tests

    search() is an ordinary call, not linked to library()

    Programmatically inspecting or mutating the search path with search(), searchpaths(), or detaching by position. None of this is modelled; search() reads as an unknown call.

    R DefinitionSearch path

    example

    library(stats)
    n <- search()
    print(n[2])

  • #Namespaces

    signature tests

    with namespace, Double Base, Simple Assign Break

    Handling R's namespaces (Advanced R). The imports environment a package carries for itself is not modelled.

  • #Accessing Exported Names

    signature tests

    With Namespace, x::f(), With Quotes and Namespace

    Resolving calls with :: to their origin. Depends on what the signature database knows; an unresolved name is left unresolved rather than reported.

    median <- function(x) 0
    median(1:3)
    stats::median(1:3)

  • #Accessing Internal Names

    Similar to :: but for internal names. Whether the name was genuinely internal rather than exported is not checked (see Namespace Exports).

    "C_cor" %in% getNamespaceExports("stats")
    stats:::C_cor$name

  • #Namespace Exports

    Know which names a package's namespace declares exported versus keeps internal. The namespace-access rule checks a ::/::: choice against what the signature database records, which omits most internal names to stay small.

    Writing R ExtensionsPackage namespaces

    example

    stats::median(1:3)
    stats:::C_cor

  • #Library Loading

    signature tests

    the resolved (assumed) R version is reported for analysis, solver.sigdb.enabled: false disables resolution and unloads the database, an explicitly namespaced call is returned as written (already qualified)

    Resolve libraries identified with library, require, attachNamespace, ... and attach them to the search path. A script binding still shadows an export.

    library(stats)
    require(utils)
    attachNamespace("tools")

  • #Library Unloading

    signature tests

    detach does not undo the attach, so a later call still resolves throu...

    Undo an attach with detach, unloadNamespace, ... Neither is modelled, so a name resolved after detach still resolves through it.

    R DefinitionSearch path

    example

    library(stats)
    median(1:3)
    detach("package:stats")
    median(1:3)

  • #Dynamic Scope Changes

    signature tests

    reads within local expression

    Manually changing scopes with a plain local block. It gets a scope of its own, and a <<- from within reaches out.

    x <- 1
    local({
      x <- 2
      x
    })
    x

  • #Local with Explicit Environment

    signature tests

    local(x <- 2, envir = .GlobalEnv) writes into the real global scope, local(x <- 2, envir = globalenv()) writes into the real global scope, list2env(envir = globalenv()) inside a function writes into the real ...

    Send local's body to a specific environment. new.env() and globalenv() work; inside a function that already binds the name, the write lands in that frame instead.

    `local`

    example

    e <- new.env()
    local(y <- 2, envir = e)
    get("y", envir = e)

  • #Anonymous Bindings

    signature tests

    Recursion with Recall, fibonacci with recall

    Support for Recall

    fact <- function(n) if(n <= 1) 1 else n * Recall(n - 1)
    fact(5)

  show 10 more

All categories

Expressions

52 fully20 partially1 not

Everything comprising the structure of an R program

• #Calls

  signature tests

  higher-order sum origin, built-in function as a value, Handle S3

  15 children1140

  • #Grouping

    signature tests

    Noop, One parameter, As Single Argument

    Recognize groups done with (, {, ... (more precisely, their default mapping to the primitive implementations).

    R DefinitionGrouping

    example

    x <- {
      1
      2
    }
    y <- (3)

  • #Normal Call

    signature tests

    f(), 'f'(), labeller force

    Recognize and resolve calls like f(x), foo::bar(x, y), ...

    R DefinitionFunction calls

    7 children520

    • #Unnamed Arguments

      signature tests

      load without any file argument is unknown side effect, an arbitrary call does not expose the definitions of its arguments, load with only envir argument is unknown side effect

      Recognize and resolve calls like f(3), foo::bar(3, c(1,2)), ...

      R DefinitionArguments

    • #Empty Arguments

      signature tests

      f(1,), get in function, subset sequence

      Essentially a special form of an unnamed argument as in foo::bar(3, ,42), ...

      R DefinitionArguments

      example

      m <- matrix(1:6, nrow = 2)
      m[1, ]
      m[, 2]

    • #Named Arguments

      signature tests

      f(x=), f(x=1), f(x=1) with comment

      Recognize and resolve calls like f(x = 3), foo::bar(x = 3, y = 4), ...

      R DefinitionArgument matching

    • #String Arguments

      Recognize and resolve calls like f('x' = 3), foo::bar('x' = 3, "y" = 4), ...

    • #Resolve Arguments

      signature tests

      unresolved do.call target is reached-but-unknown, not dropped, higher-order fn, with alias chain

      Correctly bind arguments (including pmatch). A formal behind ... matches only exactly, and an ambiguous prefix binds nothing.

      R DefinitionArgument matching

      example

      f <- function(verbose = FALSE, value = 0) c(verbose, value)
      f(TRUE, val = 3)
      f(verb = TRUE)

    • #Side-Effects in Argument

      signature tests

      Support assignments in function calls

      Handle side-effects of arguments (e.g., f(x <- 3), f(x = y <- 3), ...). Whether the argument is ever forced is not modelled, so f <- function(a) 1; f(x <- 3) still believes x is 3.

      R DefinitionArgument evaluation

      example

      f <- function(a) a
      f(x <- 3)
      x

    • #Side-Effects in Function Call

      signature tests

      assign to parent.frame escapes, a super-assigning user replacement binds outside the frame, always dominating

      Handle side-effects of function calls (e.g., setXTo(3), ...) achieved via super assignment. A <<- reaches the caller through several call levels; a write through a shared environment is missed.

      set_x <- function(v) x <<- v
      set_x(3)
      x

  • #Recursion

    signature tests

    recursion, fibonacci with recall, ping-pong-rec

    Recognize and resolve recursive calls like f(3) inside the definition of f, ...

    fib <- function(n) if(n < 2) n else fib(n - 1) + fib(n - 2)
    fib(10)

  • #Anonymous Calls

    signature tests

    Call edges for error, Calling with a constant function, Double call with only the second one being direct

    Recognize and resolve calls like (function(x) x)(3), factory(0)(), ...

    (function(x) x + 1)(3)
    factory <- function() function() 42
    factory()()

  • #Infix Calls

    signature tests

    1 %xx% 2, No Parenthesis, Invert precedence

    Recognize and resolve calls like x + y, x %>% f(y), ...

    R DefinitionInfix and prefix operators

    example

    identical(1 + 2, `+`(1, 2))

  • #Redefinition of Built-In Functions/primitives

    signature tests

    redefine in local scope, redefining assignments should work

    Handle cases like print <- function(x) x, `for` <- function(a,b,c) a, ... A redefined name wins wherever the built-in would have been used, with scope and order respected. Only ::/::: are exempt.

    R DefinitionBuiltin objects and special forms

    example

    `+` <- function(a, b) a * b
    2 + 3

  • #Functions with global side effects

    signature tests

    Sink, nested rm, Effects by pdf

    Support functions like setwd which have an impact on the subsequent program. Only the working directory is interpreted; other ambient state is an unknown side effect.

    setwd("/tmp")
    read.csv("data.csv")

  • #Working Directory

    Track the effective working directory across setwd, control-flow- and location-sensitive. Interprocedural, sourced, and loop cases are treated as unbounded.

• #Index Access

  The bracket, double-bracket, dollar, and slot forms for picking an element out of a container, with names, empty positions, and multiple indices.

  7 children700

  • #Single Bracket Access

    signature tests

    One Variable, Chained, Empty Access

    Detect calls like x[i], x[i, ,b], x[3][y], ... This does not include the real separation of cells, which is handled extra.

    l <- list(a = 1, b = 2)
    l["a"]
    l[c("a", "b")]

  • #Double Bracket Access

    signature tests

    One Constant, Empty, Multiple

    Detect calls like x[[i]], x[[i, b]], ... Similar to single bracket.

    l <- list(a = 1, b = 2)
    l[["a"]]
    l[[2]]

  • #Dollar Access

    signature tests

    Dollar access, Nested Access, dollar constant

    Detect calls like x$y, x$"y", x$y$z, ... On a list, $ matches the name partially, so l$al reaches an element named alpha.

    R DefinitionOperators

    example

    l <- list(alpha = 1)
    l$alpha
    l$al

  • #Slot Access

    signature tests

    at constant, Slot based access

    Detect calls like x@y, x@y@z, ...

    R DefinitionClasses

    example

    setClass("P", representation(x = "numeric"))
    p <- new("P", x = 1)
    p@x

  • #Access with Argument-Names

    signature tests

    Named argument

    Detect calls like x[i = 3], x[[i=]], ...

  • #Access with Empty

    signature tests

    Empty, Empty Access, Multiple with Empty

    Detect calls like x[], x[2,,42], ...

  • #Subsetting (Multiple Indices)

    signature tests

    subset sequence, range assignment

    Detect calls like x[i > 3], x[c(1,3)], ...

    v <- c(a = 1, b = 2, c = 3)
    v[c(1, 3)]
    v[v > 1]

• #Operators

  signature tests

  a chain mixing + and - reads every operand, a chain mixing precedences reads every operand, a chain mixing calls and operators reads every operand

  R's unary, binary, and special operators, the model formula, and every way a name can be bound to a value.

  15 children1131

  • #Unary Operator

    signature tests

    ? x, Comment Breaks for Unary

    Recognize and resolve calls like +3, -3, ...

    R DefinitionOperators

  • #Binary Operator

    signature tests

    a chain mixing + and - reads every operand, a chain mixing precedences reads every operand, a chain mixing calls and operators reads every operand

    Recognize and resolve calls like 3 + 4, 3 * 4, ...

    R DefinitionOperators

    13 children931

    • #Special Operator

      signature tests

      1 %xx% 2, Must work with assigned custom pipes too, must link alias with namespace

      Recognize and resolve calls like 3 %in% 4, 3 %*% 4, ...

      R DefinitionOperator tokens

      example

      `%between%` <- function(x, r) x >= r[1] & x <= r[2]
      5 %between% c(1, 10)

    • #Model Formula

      signature tests

      simple formula, Comment Breaks for Unary, call in the lhs of a formula

      Recognize and resolve calls like y ~ x, y ~ x + z, ... The operands of ~ are non-standard evaluation, so a bare y ~ x reads neither name.

      k <- 2
      f <- y ~ poly(x, k)
      all.vars(f)

    • #Assignments and Bindings

      signature tests

      full, single, nesting

      11 children821

      • #Local Left Assignment

        signature tests

        quoted definition, full, Loop Definitions

        Handle x <- 3, x$y <- 3, ...

      • #Local Right Assignment

        signature tests

        "1 -> x -> y", "x <- 1 -> y", local define with -> in function, read after

        Handle 3 -> x, 3 -> x$y, ...

      • #Local Equal Assignment

        signature tests

        local define with = in function, read after, redefining assignments should work, Manual Max Function

        Handle x = 3, x$y = 3, ... At the start of an expression = binds a name, while inside a call it names an argument (f(a = 3)).

        x = 3
        f <- function(a) a
        f(a = x)

      • #Local Table Assignment

        Handle x[,a:=3,], ...

      • #Super Left Assignment

        signature tests

        a super-assigning user replacement binds outside the frame, Nested Global Assignments, `<<-` escapes through nested calls

        Handle x <<- 42, x$y <<- 42, ...

      • #Super Right Assignment

        signature tests

        global define with ->> in function, read after, Manual Max Function

        Handle 42 ->> x, 42 ->> x$y, ...

      • #Return Value of Assignments

        signature tests

        "x <- y <- z", Nested Global Assignments, Repeat

        Handle x <- 3 returning 3, e.g., in x <- y <- 3

        x <- y <- 3
        print(x <- 4)

      • #Assignment Functions

        signature tests

        global assign (no envir) is unchanged, "x <- 1\nx <- 2\nprint(x)", using assign as assignment

        Handle assign(x, 3), delayedAssign(x, 3), ... What a delayed assignment does when forced is not modelled.

        assign("x", 3)
        delayedAssign("y", x * 2)
        y

      • #Range Assignment

        signature tests

        range assignment

        Handle x[1:3] <- 3, x$y[1:3] <- 3, ...

        x <- 1:5
        x[2:3] <- 0
        x

      • #Replacement Functions

        signature tests

        simple argument, work with s3, nested assign

        Handle x[i] <- 3, x$y <- 3, ... as `[<-`(x, 3), ... A named argument in such a call (g(v, k = 2) <- 3) leaves its argument edge dangling.

        `second<-` <- function(x, value) {
          x[2] <- value
          x
        }
        v <- 1:3
        second(v) <- 9
        v

      • #Locked Bindings

        Handle lockBinding(x, 3), ... lockBinding is not recognized as a built-in, so the assignment it should have rejected is analyzed as an ordinary redefinition.

        R DefinitionEnvironment objects

        example

        x <- 1
        lockBinding("x", environment())
        x <- 2

      show 3 more
• #Control-Flow

  signature tests

  useless branch I, useless branch II, useless branch III

  Conditionals, the three loop forms, their jumps, and how an error leaves a computation.

  9 children810

  • #if

    signature tests

    useless branch I, useless branch II, useless branch III

    Handle if (x) y else z, if (x) y, ...

    R Definitionif

    example

    x <- if(TRUE) 1 else 2
    y <- if(FALSE) 3
    y

  • #for loop

    signature tests

    a loop body still calls, for(i in 1:10) 2, Single-vector for Loop

    Handle for (i in 1:3) print(i), ...

    R DefinitionLooping

    example

    for(i in 1:3) print(i)
    i

  • #while loop

    signature tests

    a loop body is evaluated, Next in while, Endless while loop with variables

    Handle while (x) b, ...

    R Definitionwhile

    example

    i <- 0
    while(i < 3) i <- i + 1
    i

  • #repeat loop

    signature tests

    repeat with body, simple constant repeat, Single instruction repeat

    Handle repeat {b; if (x) break}, ...

    R Definitionrepeat

    example

    i <- 0
    repeat {
      i <- i + 1
      if(i > 2) break
    }
    i

  • #break

    signature tests

    break(), while (TRUE) break, Break in condition

    Handle break (including break()) ...

    R DefinitionControl structures

    example

    for(i in 1:5) {
      if(i == 4) break
      print(i)
    }

  • #next

    signature tests

    Next in while, next(), Next

    Handle next (including next()) ...

    R DefinitionControl structures

    example

    for(i in 1:5) {
      if(i %% 2 == 0) next
      print(i)
    }

  • #switch

    signature tests

    Switch with named arguments

    Handle switch(3, "a", "b", "c"), ...

    R DefinitionControl structures

    example

    switch("b", a = , b = "ab", c = "c")
    switch(2, "one", "two")

  • #return

    signature tests

    return parameter named, read of parameter in return, simple return

    Handle return(3), ... in function definitions

    f <- function(x) {
      if(x > 0) return("pos")
      "non-pos"
    }
    f(1)

  • #Exceptions and Errors

    signature tests

    Call edges for error, Call edges for error with fn, Call edges with may built-in

    Handle try, stop, ... A path where a call throws before a write is not kept open, so tryCatch({ risky(); x <- 2 }, ...) loses x.

    R DefinitionException handlingAdvanced RConditions

    example

    tryCatch(
      stop("boom"),
      error = function(e) conditionMessage(e),
      finally = print("done")
    )

  show 1 more
• #Function Definitions

  signature tests

  Empty Function in Reconstruct, Registration with setGeneric, Simple S7 Generic Registration

  Parameters and their defaults, ..., promises, and the value a function hands back.

  7 children610

  • #Normal

    signature tests

    Noop, resolving in an environment finds the built-in, unless a definition i..., One parameter

    Handle function() 3, ...

    R DefinitionFunction definitions

  • #Formals
    4 children310

    • #Named

      signature tests

      One parameter, read of parameter, read of one parameter

      Handle function(x) x, ...

      R DefinitionArguments

    • #Default

      signature tests

      Read first parameter, One Parameter, Multiple Parameter

      Handle function(x = 3) x, ...

      f <- function(x, y = x * 2) y
      f(3)

    • #Dot-Dot-Dot

      signature tests

      parameter shadows, As Single Argument, Return ...

      Handle function(...) 3, ...

      R DefinitionDot-dot-dot

      example

      f <- function(...) sum(...)
      g <- function(...) f(..., 1)
      g(2, 3)

    • #Promises

      signature tests

      Parameters binding context, Late bindings of parameter in body, Late bindings of parameter in parameters

      Handle function(x = y) { y <- 3; x }, ... We do not model when a promise is forced, nor the writes forcing it performs.

      R DefinitionPromise objectsAdvanced RLazy evaluation

      example

      f <- function(x = y) {
        y <- 3
        x
      }
      f()

  • #Implicit Return

    signature tests

    parameter shadows, read of parameter, Read first parameter

    Handle the return of function() 3, ...

    R DefinitionFunction definitions

  • #Lambda SyntaxR 4.1.0+

    signature tests

    Calling with constant argument using lambda, assign in condition, conditional assign

    Support \(x) x, ...

    sapply(1:3, \(x) x^2)

• #Important Built-Ins

  The base-R functions we give a meaning of their own rather than treating as opaque calls, the ones that compute on the language included.

  13 children2110

  • #Non-Strict Logical Operators

    signature tests

    rhs has to depend on x

    Handle &&, ||, ...

    R DefinitionOperators

    example

    FALSE && stop("never evaluated")
    TRUE || stop("never evaluated")

  • #PipeR 4.1.0+

    signature tests

    With %>%, With %<>%, Basic Pipe

    Handle the native pipe |>. The left-hand side becomes the first argument or fills the _ placeholder.

    R DefinitionFunction calls

    example

    c(1, 2, 3) |> sum() |> sqrt()
    mtcars |> subset(cyl == 4)

  • #Pipe-BindR 4.1.0+

    signature tests

    Pipe-bind has no tree-sitter grammar production, Pipe-bind is disabled unless engine.r-shell.pipeBind is enabled, Chained pipe into a pipe-bind

    Handle the experimental pipe-bind =>, which R only enables under _R_USE_PIPEBIND_. Off by default; needs engine.r-shell.pipeBind. Tree-sitter's grammar has no production for it at all.

    R DefinitionFunction calls

    example

    mtcars |> df => lm(mpg ~ cyl, data = df)

  • #Sequencing

    signature tests

    Overwrite in For-Loop

    Handle :, seq, ... by gathering value information using abstract interpretation. seq, seq_len, seq_along, and rep are not folded even for literal arguments.

    n <- 0
    1:n
    seq_len(n)

  • #Internal and Primitive Functions

    signature tests

    Without using primitive

    Handle .Internal, .Primitive, ... The call is kept and its arguments read, but the primitive a .Primitive("sum") names is not resolved to the built-in of that name.

    R Definition.Internal and .Primitive

    example

    .Primitive("+")(1, 2)
    .Internal(inspect(1))

  • #Options

    signature tests

    Configuring options

    Handle options, getOption, ... Option values are not tracked, so getOption("digits") does not reach a preceding options(digits = 3).

    old <- options(digits = 3)
    getOption("digits")
    options(old)

  • #Help

    signature tests

    ? x

    Handle help, ?, ... ? and ?? are recognized, but their topic is read as an ordinary variable where R only looks it up, and help/help.search are not known at all.

    ?sum
    help("sum")

  • #Reflection / "Computing on the Language"

    signature tests

    map2, simple map, across with user fn

    6 children060

    • #Get Function Structure

      Handle body, formals, args, environment to access the respective parts of a function. What comes back is opaque, and reading only formals(f) keeps all of f's body in a slice.

      R DefinitionManipulation of functions

      example

      f <- function(x) x + 1
      body(f)
      formals(f)
      environment(f)

    • #Modify Function Structure

      Handle body<-, formals<-, environment<- to modify the respective parts of a function. The function is redefined, so a later call reaches the new part as well as the original one.

      R DefinitionManipulation of functions

      example

      f <- function(x) x + 1
      body(f) <- quote(x * 2)
      f(3)

    • #Quoting

      signature tests

      quoted call, substituted call, quoted definition

      Handle quote, substitute, bquote, ... A quoted argument is non-standard evaluation; substitute does not reach the caller's expression.

      R DefinitionComputing on the languageAdvanced RMetaprogramming

      example

      x <- 1
      quote(x + y)
      bquote(.(x) + y)

    • #Evaluation

      signature tests

      an evaluated capture is no longer marked as unevaluated, cli_abort stays an error exit rather than a template, eval with an unresolvable expr is an unknown side effect

      Handle eval, evalq, eval.parent, ... eval(expr, envir) runs elsewhere, so we mark it an unknown side effect.

      R DefinitionEvaluation of expressionsAdvanced REvaluation

      example

      e <- quote(x + 1)
      x <- 2
      eval(e)

    • #String Templates

      signature tests

      cli_abort stays an error exit rather than a template, every interpolation of one template gets a vertex of its own

      Handle glue::glue("{x}"), cli::cli_alert_info("{.val {x}}"), stringr::str_glue, ... A template aimed at another scope (.envir, .con, glue_data) becomes an unknown side effect.

      x <- 2
      glue::glue("x plus one is {x + 1}")

    • #Parsing

      signature tests

      simple eval use, simple eval use - from 2 variables

      Handle parse, deparse, ... deparse is not modelled beyond reading its argument.

      R DefinitionThe parsing processR DefinitionDeparsing

      example

      eval(parse(text = "1 + 1"))
      deparse(quote(x + y))

• #Literal Values
  7 children700

  • #Numbers

    signature tests

    single element, built-in constant, two files

    Recognize numbers like 3, 3.14, the integer 3L, hexadecimals such as 0xFF and 0x1p3, as well as the typed missings NA_integer_/NA_real_, ...

    R DefinitionLiteral constants

    example

    1L
    0xFF
    1e-3
    0x1p3
    NA_real_

    1 child100

    • #Complex

      Recognize the imaginary literals 1i, 4.1i, 1e-2i, ... The value survives arithmetic and is told apart from 1L and a plain 1.

      R DefinitionLiteral constants

      example

      z <- 1i
      z + 2i
      3 + 2i

  • #Strings

    signature tests

    built-in vector constant, missing source, conditional

    Recognize strings like "a", 'b', ...

    R DefinitionLiteral constants

    1 child100

    • #Raw StringsR 4.1.0+

      Recognize raw strings like r"(a)", ...

      r"(C:\Users\me)"
      r"[\d+]"

  • #Logical

    signature tests

    while (TRUE) 42, while (TRUE) break, completely constant

    Recognize the logicals TRUE and FALSE, ... Their short forms T and F are ordinary bindings and can be reassigned, while TRUE and FALSE are reserved.

    R DefinitionConstants

    example

    TRUE && FALSE
    T <- FALSE
    T

  • #NULL

    Recognize NULL

    R DefinitionNULL object

    example

    c(1, NULL, 2)
    l <- list(a = 1)
    l$a <- NULL
    length(l)

  • #Inf and NaN

    Recognize Inf and NaN

    1 / 0
    -1 / 0
    0 / 0
    is.nan(NA)

All categories

Non-Standard Evaluations/Semantics

1 fully5 partially1 not

Specific support for R's NSE/Reflection semantics

• #Data Masking

  signature tests

  a classed closure in a mask keeps its read, a masked name the caller binds reads the data as well

  Handle subset(d, col > 1), dplyr verbs, ggplot2::aes, data.table :=, ... Which columns exist is unknown to us, so a column shadowing a variable still resolves to the variable.

  d <- data.frame(x = 1:3)
  threshold <- 2
  subset(d, x > threshold)

• #Recycling

  Handle recycling of vectors as explained in Advanced R. We do not support recycling.

  R DefinitionRecycling rulesAdvanced RVectors

  example

  c(1, 2, 3, 4) + c(10, 20)

• #Vectorized Operator or Functions

  Handle vectorized operations as explained in Advanced R. Comparisons, the reducing functions, and ifelse widen to the unknown value.

  x <- 1:5
  x * 2
  ifelse(x > 2, "big", "small")

• #Hooks

  signature tests

  call on.exit at the end, with add, on.exit\'s append, on.exit closure reads last value

  Handle hooks like userhooks and on.exit. setHook is not modelled.

  f <- function() {
    on.exit(print("bye"))
    1
  }
  f()

• #Precedence

  signature tests

  def compare in loop, Must work with assigned custom pipes too, if-then

  Handle the precedence of operators as explained in the Documentation. We handle the precedence of operators (implicitly with the parser).

  R DefinitionOperator tokens

  example

  -2^2
  1:3 - 1
  !TRUE == FALSE

• #Attributes
  2 children020

  • #User-Defined

    Handle attributes like attr, attributes, ... Which attributes an object carries is not part of the value we track.

    R DefinitionAttributes

    example

    x <- 1:3
    attr(x, "unit") <- "cm"
    attributes(x)

  • #Built-In

    signature tests

    useless branch I, useless branch II, useless branch III

    Handle built-in attributes like dim, ... dim<-, names<-, class<- track shape on a data frame; elsewhere the attribute values are not tracked.

    R DefinitionDimensional attributes

    example

    x <- 1:6
    dim(x) <- c(2, 3)
    class(x)

All categories

Object-Oriented Programming

2 fully9 partially1 not

R's object systems and what their classes and dispatch tell us about a program.

• #S3

  signature tests

  Handle S3, Simple S3 dispatch, Respect Later-Defs

  Classes and methods built on the class attribute and UseMethod dispatch.

  Advanced RS3R DefinitionObject-oriented programming

  example

  p <- structure(list(n = "ada"), class = "pt")
  print.pt <- function(x, ...) cat("pt", x$n, "\n")
  p

  3 children120

  • #Class Construction

    signature tests

    a class named where an object is constructed counts as a use of that ..., Dispatch through a base generic

    Give an object its class with structure(..., class =), class<-, or oldClass<-. The class a literal names is tracked and reaches the dispatch that follows it.

    R DefinitionObjects

  • #Dispatch

    signature tests

    Simple S3 dispatch, Respect Later-Defs, Two-Targets S3 dispatch

    Route a generic call to the method that runs. UseMethod links to every generic.class in scope (heavily over-approximating).

    R DefinitionUseMethodR DefinitionMethod dispatching

  • #Inheritance

    signature tests

    Simple S3 dispatch with NextMethod

    Walk the class vector with NextMethod. It reaches the generic's methods, the one it stands in included, rather than only the next class in the vector.

    R DefinitionNextMethodR DefinitionInheritance

• #S4

  signature tests

  S4 setMethod, S4 new reads its class registration, S4 setMethod reads the generic it answers

  Formal classes and methods declared with setClass, setGeneric, and setMethod.

  Advanced RS4

  example

  setClass("P", representation(x = "numeric"))
  setGeneric("desc", function(o) standardGeneric("desc"))
  setMethod("desc", "P", function(o) o@x)
  desc(new("P", x = 1))

  3 children111

  • #Class Construction

    signature tests

    S4 new reads its class registration, S4 setClass reads the class it extends

    Declare a class with setClass and build one with new. The new call is linked to the setClass that declared the class, and a slot is read through @ like any other access.

    R DefinitionClasses

  • #Dispatch

    signature tests

    S4 setMethod, S4 setMethod reads the generic it answers

    Route a generic call to the method setMethod registered. The generic reaches its methods through the chain they register in, but the signature does not narrow which of them runs.

    R DefinitionMethod dispatching

  • #Inheritance

    signature tests

    S4 setClass reads the class it extends

    Reach a parent method with callNextMethod, and inherit through contains. callNextMethod is left unresolved, so nothing links it to the method it would call.

    R DefinitionInheritance

• #RC/R5

  Reference classes made with setRefClass, whose objects are mutable. $new() and $method() on an instance are unknown side effects; no call links to the body it runs.

  Advanced RR5 / Reference classes

  example

  Acc <- setRefClass("Acc",
    fields = list(bal = "numeric"),
    methods = list(dep = function(v) bal <<- bal + v))
  a <- Acc$new(bal = 0)
  a$dep(5)

• #R6

  Handle R6 classes and methods as one unit. We do not support typing, inheritance, private/active bindings, or handling objects fully "as units."

  Advanced RR6

  example

  Counter <- R6::R6Class("Counter", public = list(
    i = 0,
    add = function() {
      self$i <- self$i + 1
      invisible(self)
    }
  ))
  Counter$new()$add()$i

• #R7/S7

  signature tests

  Registration with setGeneric, Simple S7 Generic Registration, Simple S7 Generic Method and Call

  Handle R7 classes and methods as one unit, dispatch and inheritance included. Typing is not supported, nor are objects handled fully "as units."

  R7S7

  example

  Person <- S7::new_class("Person", properties = list(name = S7::class_character))
  Person(name = "ada")@name

• #Class-Based Dependency Attribution

  signature tests

  an S3 method registered for a class NOT owned by any package does not..., a bare class-name string in code does NOT introduce an unrelated pack..., a class owned by a declared but never called dependency is resolved w...

  Attribute the use of a class to the package that owns it, so a class use implies a dependency for library detection and version guessing.

  2 children020

  • #S3 class ownership

    signature tests

    an S3 method registered for a class NOT owned by any package does not..., a bare class-name string in code does NOT introduce an unrelated pack..., a class owned by a declared but never called dependency is resolved w...

    Attribute an S3 class to the package that owns it. A class name from a variable or a c(...) vector is not resolved.

  • #S4 class ownership

    signature tests

    importClassesFrom / importMethodsFrom register their source package (S4)

    Attribute an S4 class to the package that owns it. S4 ownership is not in the signature database, so a bare class use is not attributed.

All categories

R File Structure

5 fully4 partially0 not

The lexical shape of a source file, down to its line endings and encoding.

• #Comments

  signature tests

  simple line comment, With comments in parameter, single

  Recognize comments like # this is a comment, including a shebang line, ...

  R DefinitionComments

  example

  #!/usr/bin/env Rscript
  # a comment
  x <- 1 # a trailing comment

• #Line Directive

  signature tests

  Simple line

  Recognize #line n "file" as its own node (r-shell only). It is parsed but never retargets a location; tree-sitter reads it as a comment.

  R Definitionparse

  example

  x <- 1
  #line 42 "other.R"
  y <- 2

• #Semicolons

  signature tests

  Two Elements in Same Line, Empty split with semicolon, Inconsistent split with semicolon

  Recognize and resolve semicolons like a; b; c, ...

  R DefinitionSeparators

  example

  a <- 1; b <- 2; a + b

• #Newlines

  signature tests

  directly together, CRLF parses identically to LF, lone CR parses identically to LF

  Recognize and resolve newlines like a\nb\nc; a newline ends an expression unless it is still incomplete. A trailing operator or an unclosed bracket continues on the next line.

  R DefinitionSeparators

  example

  x <- 1 +
    2
  y <- 1
    + 2

• #Line Endings

  signature tests

  CRLF parses identically to LF with the tree-sitter engine, CRLF parses identically to LF, lone CR parses identically to LF

  Recognize \n (Unix), \r\n (Windows), and a lone \r (classic Mac). Normalized at the r-bridge boundary, with both engines.

  x <- 1
  y <- x + 1

• #Source Encoding

  signature tests

  hex byte escapes decode to UTF-8, octal byte escapes decode to UTF-8, non-ASCII names, strings, and comments survive

  Recognize non-ASCII source, i.e., UTF-8 in string literals, in comments, and in identifiers (plain as well as backtick-escaped). Such names bind and resolve like any other, with both engines.

  R DefinitionTokens

  example

  stärke <- "café"
  `α β` <- 2
  stärke

• #Byte-Order Mark

  signature tests

  a leading BOM does not change the program

  Recognize a UTF-8 byte-order mark at the start of a file. The tree-sitter engine reads past it, the r-shell engine rejects the same input as unparsable.

• #Syntax Errors

  signature tests

  unbalanced brace, missing closing parenthesis, valid code has no syntax errors

  Handle source that does not parse. The syntactically-valid rule locates the region and offers a fix; the strict parser rejects the file, tree-sitter's lax mode (off by default) drops the region.

  R DefinitionThe parsing process

  example

  x <- 1
  y <- (
  z <- 3

• #Reserved Words

  signature tests

  r-shell rejects `if <- 5`, matching R, tree-sitter silently drops `if <- 5`, unlike r-shell

  Reject a syntactic keyword like `if` or `function` where R's grammar requires an expression. The r-shell engine rejects if <- 5; tree-sitter's grammar parses it as an ordinary assignment.

  R DefinitionReserved words

  example

  if <- 5

All categories

Project

9 fully4 partially0 not

Support for non-R/project files (dependencies, etc.).

• #Package Metadata

  The files that describe the package itself, what it needs, and what it offers.

  5 children410

  • #DESCRIPTION

    signature tests

    Loading-Order-Plugin, Declared package names span every dependency field

    Read a package's DESCRIPTION. Its DCF records give the package name, version, R version, dependency fields, and Collate order.

    plugindescription-fileWriting R ExtensionsThe DESCRIPTION file

  • #NAMESPACE

    signature tests

    Functions are exported, Imports are registered correctly, importClassesFrom / importMethodsFrom register their source package (S4)

    Read a package's NAMESPACE. Acts on import/importFrom, importClassesFrom/importMethodsFrom for S4, and export/S3method.

    pluginnamespace-fileWriting R ExtensionsPackage namespaces

  • #Documentation (`.Rd`)

    signature tests

    a page without a \\name{} falls back to the file name, name, docType, title, keywords, aliases, usage and arguments

    Read the .Rd pages under man/, their macros, and the indices beside them. A documented name is tied back to the page that documents it.

    pluginrd-fileWriting R ExtensionsRd format

  • #NEWS

    signature tests

    Parse the News!

    Read a package's NEWS/NEWS.md. We parse the versions it announces and what each changed, which is what a version guess is checked against.

    pluginnews-fileWriting R ExtensionsPackage subdirectories

  • #Package Data (`sysdata.rda`)

    signature tests

    the package\'s own code reads them without anything bringing them in, a source package is tagged as data and states its objects with the ty...

    Read the R/sysdata.rda a package keeps its internal data in, and the data/ files it exports. What those bindings hold is not reconstructed.

    pluginsysdata-fileWriting R ExtensionsData in packages

• #Dependency Managers

  The lockfiles and manifests a version manager pins a project's packages with.

  5 children410

  • #renv

    signature tests

    renv.lock pins every package, a lockfile is read whatever its name is capitalized like

    Read the configuration of renv, the most widespread R project-library manager. The library it points at is neither installed nor restored.

    pluginanalyzer-package-versions-lockfilerenv

  • #packrat

    signature tests

    packrat.lock pins every package, packrat.lock contributes its RVersion, the lockfile is discovered and read, the installed library is not

    Read the configuration of packrat, the predecessor of renv. The packrat/lib library beside it is not loaded.

    pluginanalyzer-package-versions-lockfilepackrat

  • #rv

    signature tests

    rv.lock contributes its r_version, rv.lock pins every package, including builtin ones

    Read the configuration of rv, a declarative project manager in the style of cargo. Parses rproject.toml and the resolved rv.lock.

    pluginmanifest-filesrv

  • #uvr

    signature tests

    uvr.lock contributes the version of its [r] table, uvr.lock pins every package, including the dev ones, the manifest and the lockfile are read, the project library is not

    Read the configuration of uvr, an R project manager modelled on uv. Parses uvr.toml and the uvr.lock beside it.

    pluginmanifest-filesuvr

  • #Installed Library

    signature tests

    the lockfile is discovered and read, the installed library is not, the manifest and the lockfile are read, the project library is not

    Read the package library a project installs into (renv/library, packrat/lib, or the platform library). Their code is not read.

    pluginanalyzer-package-versions-library

• #Startup and Discovery

  What runs before a script does and what counts as part of the project at all.

  2 children110

  • #Startup Files

    signature tests

    a discovered .Rprofile is loaded first, .Rprofile and Rprofile.site are tagged Startup and Source, .Renviron and Renviron.site are tagged Environment but not Source

    Read the files R runs or reads before a script (.Rprofile, Rprofile.site, .Renviron, Renviron.site). Variables set by an environment file are not interpreted.

    pluginanalyzer-rprofile-fileR DefinitionStartup

  • #Ignore Files

    signature tests

    the combined plugin respects both files, .Rbuildignore drops matching files and whole directories

    Read the .gitignore and .Rbuildignore that say which files are not part of the project. Follows gitignore globs and the regular expressions R CMD build uses.

    pluginanalyzer-ignore-file-project-discoverygitignore

• #Pre-Processors/external Tooling

  The tooling around R code rather than the R in it, such as roxygen2 blocks and woven documents.

  1 child010

  • #roxygen2

    Handle the roxygen2 blocks that precede a definition. What a tag states does not reach name resolution, so an @importFrom leaves the name below it unqualified.

    roxygen2

    example

    #' @param x a number
    #' @importFrom stats median
    #' @export
    mid <- function(x) median(x)

All categories

System, I/O, FFI, and Other Files

0 fully9 partially0 not

Everything a program reaches for beyond its own code, from files it reads to calls it makes out of R.

• #Sourcing External Files

  signature tests

  missing source, conditional, multiple source

  Handle source, sys.source, ... We are currently working on supporting the inclusion of external files. Currently we can handle source.

  source("helpers.R")
  sys.source("setup.R", envir = environment())

• #Handling Binary Files

  signature tests

  a source package is tagged as data and states its objects with the ty...

  Handle files dumped with, e.g., save, ... The values behind a loaded name are not reconstructed.

  R Definitionsave

  example

  save(x, file = "x.RData")
  load("x.RData")
  readRDS("y.rds")

• #I/O

  Handle read.csv, write.csv, ... What a file contains does not enter the analysis.

  R DefinitionOperating system access

  example

  d <- read.csv("in.csv")
  write.csv(d, "out.csv")

• #Foreign Function Interface

  Handle .C, .Call, .External, .Fortran, ... The call carries an unknown side effect; the foreign code behind it is not analyzed.

  .Call("my_c_fn", 1)
  .Fortran("my_f_sub", x = 1)

• #System Calls

  signature tests

  unknown system

  Handle system, system.*, ... An injectable command built from user input is flagged by the problematic-inputs and unescaped-arguments rules.

  R DefinitionOperating system access

  example

  system("ls -la")
  system2("git", c("status"))

• #R-Markdown files

  Support R-Markdown files as R sources. Code chunks are extracted; inline r expr and the params object of the YAML front matter are not.

  R Markdown

• #Jupyter Notebook

  Support Jupyter Notebooks as R sources. Cells are read in document order, not execution order, and the kernel is not checked.

  Jupyter Notebook Format

• #Quarto

  Support Quarto files as R sources. Code chunks are extracted; inline r expr and the params object of the YAML front matter are not.

  Quarto

• #Sweave

  signature tests

  unnamed

  Support for Sweave files as R sources. Code chunks are extracted, \Sexpr{} inline expressions are not.

  Sweave

All categories

Types

0 fully1 partially3 not

What a value is, how we infer it from the code, and the coercions R applies between types.

• #Primitive

  Recognize and resolve primitive types like numeric, character, ... typeof, class, and mode are not evaluated and resolve to the unknown top value.

  R DefinitionBasic types

  example

  typeof(1L)
  class(1)
  mode("a")

• #Non-Primitive

  Recognize and resolve non-primitive/composite types. The type of a list, a data frame, or any other composite is not tracked, so class(list(1, 2)) resolves to the unknown top value.

  R DefinitionVector objects

• #Inference

  Infer types from the code. A type predicate never narrows a branch, so if(is.numeric(1)) y <- 1 else y <- "a" still leaves y as both alternatives.

• #Coercion

  Handle coercion of types. A vector is not unified: c(1, "a") keeps a number beside a string, and the as.* converters are not evaluated.

  R DefinitionBasic types

  example

  c(1, "a")
  TRUE + 1
  as.integer("3")