Project the vector out of SEXPs.

A view of R's internal SEXP structure as an algebraic datatype. Because this is in fact a GADT, the use of named record fields is not possible here. Named record fields give rise to functions for whom it is not possible to assign a reasonable type (existentially quantified type variables would escape).

See https://cran.r-project.org/doc/manuals/r-release/R-ints.html#SEXPTYPEs.

Heterogeneous equality.

The R monad, for sequencing actions interacting with a single instance of the R interpreter, much as the IO monad sequences actions interacting with the real world. The R monad embeds the IO monad, so all IO actions can be lifted to R actions.

Create an R character string from a Haskell string.

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.

IsList a holds iff R's is.list() returns TRUE.

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.

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.

Finalize an R instance.

The singleton kind-indexed type family.

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

Values that can be converted to SEXP.

A SEXP of unknown form.

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

Internalize a symbol name.

Evaluate a (sequence of) expression(s) in the global environment.

R's NULL value.

Special value to which all symbols unbound in the current environment resolve to.

Value substituted for all missing actual arguments of a function call.

The base environment.

The empty environment.

The global environment.

R uses three-valued logic.

Used where the R documentation speaks of "pairlists", which are really just regular lists.

Constraint synonym grouping all vector forms into one class. IsVector a holds iff R's is.vector() returns TRUE.

Non-atomic vector forms. See src/main/memory.c:SET_VECTOR_ELT in the R source distribution.

IsPairList a holds iff R's is.pairlist() returns TRUE.

Constraint synonym grouping all expression forms into one class. According to R internals, an expression is usually a Lang, but can sometimes also be an Expr or a Symbol.

Manually trigger processing all pending events. Useful when at an interactive prompt and no event loop is running.

Silent version of eval function that discards it's result.

Evaluate a (sequence of) expression(s) in the given environment, returning the value of the last.

Cancel any ongoing R computation in the current process. After interruption an RError exception will be raised.

This call is safe to run in any thread. If there is no R computation running, the next computaion will be immediately cancelled. Note that R will only interrupt computations at so-called "safe points" (in particular, not in the middle of a C call).

Throw an R error as an exception.

Throw an R exception with specified message.

Parse file and perform some actions on parsed file.

This function uses continuation because this is an easy way to make operations GC-safe.

Create an R string vector from a Haskell string.

Declare memory management for this value to be automatic. That is, the memory associated with it may be freed as soon as the garbage collector notices that it is safe to do so.

Values with automatic memory management are tagged with the global region. The reason is that just like for other global values, deallocation of the value can never be observed. Indeed, it is a mere "optimization" to deallocate the value sooner - it would still be semantically correct to never deallocate it at all.

automatic for SomeSEXP.

A view function projecting a view of SEXP as an algebraic datatype, that can be analyzed through pattern matching.

Run an R action in the global R instance from the IO monad. This action provides no static guarantees that the R instance was indeed initialized and has not yet been finalized. Make sure to call it within the scope of withEmbeddedR.

runRegion m fully evaluates the result of action m, to ensure that no thunks hold onto resources in a way that would extrude the scope of the region. This means that the result must be first-order data (i.e. not a function).

throws Error. Generaly any R function may throw RError that is safe to be cached and computation can proceed. However RError will cancel entire R block. So in order to catch exception in more fine grained way one has to use function tryCatch inside R block.

Configuration options for the R runtime. Configurations form monoids, so arguments can be accumulated left-to-right through monoidal composition.

Default argument to pass to initialize.

Create a new embedded instance of the R interpreter. Only works from the main thread of the program. That is, from the same thread of execution that the program's main function is running on. In GHCi, use -fno-ghci-sandbox to achieve this.

Create a pairlist from an association list. Result is either a pairlist or nilValue if the input is the null list. These are two distinct forms. Hence why the type of this function is not more precise.

Create an association list from a pairlist. R Pairlists are nil-terminated chains of nested cons cells, as in LISP.

Like fromSEXP, but with no static type satefy. Performs a dynamic (i.e. at runtime) check instead.

Create a SEXP value and protect it in current region

Like fromSomeSEXP, but behaves like the as.* family of functions in R, by performing a best effort conversion to the target form (e.g. rounds reals to integers, etc) for atomic types.

An R value, expressed as an R expression, in R's syntax.

Quasiquoter for pure R code (no side effects) and that does not depend on the global environment (referential transparency). This means that all symbols must appear qualified with a package namespace (whose bindings are locked by default), the code must not affect R shared state in any way, including the global environment, and must not perform I/O.

Map backwards slashes to forward slashes.

Find all occurences of antiquotations.

This function works by parsing the user's R code in a separate R process. As a nice side-effect, it will detect and return any syntax errors in the quasi-quoted R code.

This function is exposed only for testing; you probably don't need to call it in the user code.

The class of R interaction monads. For safety, in compiled code we normally use the R monad. For convenience, in a GHCi session, we normally use the IO monad directly (by means of a MonadR instance for IO, imported only in GHCi).

acquire for SomeSEXP.

A reification of an R execution context, i.e. a "session".

A form of the printR function that is more convenient in an interactive session.

A form of the printR function that is more convenient in an interactive session.