ns-load

R Base 3.6.2

Functions to load and unload name spaces.

Syntax

attachNamespace(ns, pos = 2L, depends = NULL, exclude, include.only)
loadNamespace(package, lib.loc = NULL,
              keep.source = getOption("keep.source.pkgs"),
              partial = FALSE, versionCheck = NULL,
              keep.parse.data = getOption("keep.parse.data.pkgs"))
requireNamespace(package, ..., quietly = FALSE)
loadedNamespaces()
unloadNamespace(ns)
isNamespaceLoaded(name)

Arguments

Parameter	Description
`ns`	string or name space object.
`pos`	integer specifying position to attach.
`depends`	NULL or a character vector of dependencies to be recorded in object .Depends in the package.
`package`	string naming the package/name space to load.
`lib.loc`	character vector specifying library search path.
`keep.source`	Now ignored except during package installation.
`keep.parse.data`	Ignored except during package installation.
`partial`	logical; if true, stop just after loading code.
`versionCheck`	NULL or a version specification (a list with components op and version).
`quietly`	logical: should progress and error messages be suppressed?
`name`	string or ‘name’, see as.symbol, of a package, e.g., "stats".
`exclude, include.only`	character vectors; see library.
`…`	further arguments to be passed to loadNamespace.

Return Value

attachNamespace returns invisibly the package environment it adds to the search path. loadNamespace returns the name space environment, either one already loaded or the one the function causes to be loaded. requireNamespace returns TRUE if it succeeds or FALSE. loadedNamespaces returns a character vector. unloadNamespace returns NULL, invisibly.

Details

The functions loadNamespace and attachNamespace are usually called implicitly when library is used to load a name space and any imports needed. However it may be useful at times to call these functions directly. loadNamespace loads the specified name space and registers it in an internal data base. A request to load a name space when one of that name is already loaded has no effect. The arguments have the same meaning as the corresponding arguments to library, whose help page explains the details of how a particular installed package comes to be chosen. After loading, loadNamespace looks for a hook function named .onLoad as an internal variable in the name space (it should not be exported). Partial loading is used to support installation with lazy-loading. Optionally the package licence is

Examples

Example

# NOT RUN {
 (lns <- loadedNamespaces())
 statL <- isNamespaceLoaded("stats")
# }
# NOT RUN {
<!-- % checks work also when it is *not* loaded -->
# }
# NOT RUN {
 stopifnot( identical(statL, "stats" %in% lns) )

 ## The string "foo" and the symbol 'foo' can be used interchangably here:
 stopifnot( identical(isNamespaceLoaded(  "foo"   ), FALSE),
            identical(isNamespaceLoaded(quote(foo)), FALSE),
            identical(isNamespaceLoaded(quote(stats)), statL))

hasS <- isNamespaceLoaded("splines") # (to restore if needed)
Sns <- asNamespace("splines") # loads it if not already
stopifnot(   isNamespaceLoaded("splines"))
unloadNamespace(Sns) # unloading the NS 'object'
stopifnot( ! isNamespaceLoaded("splines"))
if (hasS) loadNamespace("splines") # (restoring previous state)
# }