The basic type of all R expressions, classified by the form of the expression, and the memory region in which it has been allocated.

A SEXP of unknown form.

Deconstruct a SomeSEXP. Takes a continuation since otherwise the existentially quantified variable hidden inside SomeSEXP would escape.

Cast the type of a SEXP into another type. This function is partial: at runtime, an error is raised if the source form tag does not match the target form tag.

Cast form of first argument to that of the second argument.

Unsafe coercion from one form to another. This is unsafe, in the sense that using this function improperly could cause code to crash in unpredictable ways. Contrary to cast, it has no runtime cost since it does not introduce any dynamic check at runtime.

Allocate a SEXP.

Allocate a pairlist of SEXPs, chained together.

Allocate Vector.

Intern a string name into the symbol table.

If name is not found, it is added to the symbol table. The symbol corresponding to the string name is returned.

Initialize a new string vector.

Initialize a new character vector (aka a string).

Content encoding.

Create Character value with specified encoding

Return the "type" tag (aka the form tag) of the given SEXP. This function is pure because the type of an object does not normally change over the lifetime of the object.

Check if object is an S4 object.

This is a function call so it will be more precise than using typeOf.

Set the attribute list.

Get attribute with the given name.

Get the attribute list from the given object.

Allocate a so-called cons cell, in essence a pair of SEXP pointers.

Allocate a so-called cons cell of language objects, in essence a pair of SEXP pointers.

read CAR object value

read CDR object

read object`s Tag

Set CAR field of object, when object is viewed as a cons cell.

Set CDR field of object, when object is viewed as a cons cell.

Set TAG field of object, when object is viewed as a cons cell.

Enclosing environment.

Hash table associated with the environment, used for faster name lookups.

Closure formals (aka the actual arguments).

The code of the closure.

The environment of the closure.

The code of a promise.

The environment in which to evaluate the promise.

The value of the promise, if it has already been forced.

Read a name from symbol.

Read value from symbol.

Read internal value from symbol.

Length of the vector.

Read True Length vector field.

Read character vector data

Read real vector data.

Read integer vector data.

Read logical vector data.

Read complex vector data.

Read raw data.

Read string vector data.

Extract the data pointer from a vector.

Inverse of vectorPtr.

Evaluate any SEXP to its value.

Try to evaluate expression.

Try to evaluate without printing error/warning messages to stdout.

Construct a nullary function call.

Construct unary function call.

Construct a binary function call.

Find a function by name.

Find a variable by name.

Protect a SEXP from being garbage collected by R. It is in particular necessary to do so for objects that are not yet pointed by any other object, e.g. when constructing a tree bottom-up rather than top-down.

To avoid unbalancing calls to protect and unprotect, do not use these functions directly but use withProtected instead.

unprotect n unprotects the last n objects that were protected.

Unprotect a specific object, referred to by pointer.

Preserve an object accross GCs.

Allow GC to remove an preserved object.

Invoke an R garbage collector sweep.

Global nil value. Constant throughout the lifetime of the R instance.

Unbound marker. Constant throughout the lifetime of the R instance.

Missing argument marker. Constant throughout the lifetime of the R instance.

The base environment.

The empty environment.

Global environment.

Signal handler switch

Flag that shows if computation should be interrupted.

Info header for the SEXP data structure.

Extract the header from the given SEXP.

Write a new header.

Set the GC mark.

Add a type index to the pointer.

Remove the type index from the pointer.

Release object into another region. Releasing is safe so long as the target region is "smaller" than the source region, in the sense of '(Control.Memory.Region.<=)'.

Perform an action with resource while protecting it from the garbage collection. This function is a safer alternative to protect and unprotect, guaranteeing that a protected resource gets unprotected irrespective of the control flow, much like bracket_.