import::into functions provide an
alternative way to import objects (e.g. functions) from packages. It is
sometimes preferred over using
require) which will
import all objects exported by the package. The benefit over
pkg::obj is that the imported objects will (by default) be placed in a
separate entry in the search path (which can be specified), rather in the
global/current environment. Also, it is a more succinct way of importing
several objects. Note that the two functions are symmetric, and usage is a
matter of preference and whether specifying the
.into argument is
desired. The function
import::here imports into the current environment.
from( .from, ..., .into = "imports", .library = .libPaths()[1L], .directory = ".", .all = (length(.except) > 0), .except = character(), .chdir = TRUE, .character_only = FALSE ) here( .from, ..., .library = .libPaths()[1L], .directory = ".", .all = (length(.except) > 0), .except = character(), .chdir = TRUE, .character_only = FALSE ) into( .into, ..., .from, .library = .libPaths()[1L], .directory = ".", .all = (length(.except) > 0), .except = character(), .chdir = TRUE, .character_only = FALSE )
The package from which to import.
Names or name-value pairs specifying objects to import. If arguments are named, then the imported object will have this new name.
The name of the search path entry. Enclosing the value in curly
brackets causes the parameter to be treated as an actual
environment value, rather than the name of an environment. Using
character specifying the library to use when importing from packages. Defaults to the latest specified library.
character specifying the directory to use when importing
from modules. Defaults to the current working directory. If .from is a
module specified using an absolute path (i.e. starting with
logical specifying whether all available objects in a package or module should be imported. It defaults to FALSE unless .exclude is being used to omit particular functions.
character vector specifying any objects that should
not be imported. Any values specified here override both values
logical specifying whether to change directories before sourcing a module (this parameter is ignored for libraries)
A logical indicating whether
a reference to the environment containing the imported objects.
The function arguments can be quoted or unquoted as with e.g.
In any case, the character representation is used when unquoted arguments are
provided (and not the value of objects with matching names). The period in
the argument names
.from are there to avoid name
clash with package objects. The double-colon syntax
allows for imports of exported objects (and lazy data) only. To import
objects that are not exported, use triple-colon syntax, e.g.
import:::from. The two ways of calling the
::: operators themselves.
Note that the
import functions usually have the (intended) side-effect
of altering the search path, as they (by default) import objects into the
"imports" search path entry rather than the global environment.
import package is not meant to be loaded with
will output a message about this if attached), but rather it is named to make
the function calls expressive without the need to loading before use, i.e. it is
designed to be used explicitly with the
:: syntax, e.g.
import::from(pkg, x, y).
import can either be used to import objects either from R packages or
R source files. If the
.from parameter ends with '.R' or
import will look for a source file to import from. A source file
in this context is referred to as a
module in the documentation.
import you can specify package version requirements. To do this
add a requirement in parentheses to the package name (which then needs to
be quoted), e.g
import::from("parallel (>= 3.2.0)", ...).
You can use the operators
!=. Whitespace in the specification is irrelevant.
import::from(parallel, makeCluster, parLapply) import::into("imports:parallel", makeCluster, parLapply, .from = parallel)