Spell correction

R/ClusterFuture-class.R

@@ -1,4 +1,4 @@
-#' A cluster future is a future whose value will be resolved asynchroneously in a parallel process
+#' A cluster future is a future whose value will be resolved asynchronously in a parallel process
 #'
 #' @inheritParams MultiprocessFuture-class
 #' @param globals (optional) a logical, a character vector,

R/MulticoreFuture-class.R

@@ -1,4 +1,4 @@
-#' An multicore future is a future whose value will be resolved asynchroneously in a parallel process
+#' An multicore future is a future whose value will be resolved asynchronously in a parallel process
 #'
 #' @inheritParams MultiprocessFuture-class
 #'

R/MultiprocessFuture-class.R

@@ -1,4 +1,4 @@
-#' An multiprocess future is a future whose value will be resolved asynchroneously in a parallel process
+#' An multiprocess future is a future whose value will be resolved asynchronously in a parallel process
 #'
 #' @inheritParams Future-class
 #' @param local If TRUE, the expression is evaluated such that

R/UniprocessFuture-class.R

@@ -1,4 +1,4 @@
-#' An uniprocess future is a future whose value will be resolved synchroneously in the current process
+#' An uniprocess future is a future whose value will be resolved synchronously in the current process
 #'
 #' @inheritParams Future-class
 #' @param lazy If \code{FALSE} (default), then the setup and validation of

R/cluster.R

@@ -1,4 +1,4 @@
-#' Create a cluster future whose value will be resolved asynchroneously in a parallel process
+#' Create a cluster future whose value will be resolved asynchronously in a parallel process
 #'
 #' A cluster future is a future that uses cluster evaluation,
 #' which means that its \emph{value is computed and resolved in

R/future.R

@@ -78,7 +78,7 @@
 #' \emph{Note that this means that the expression of a lazy future will
 #' not be evaluated unless the value is requested}.
 #'
-#' For future assignments, lazy evaluation can be controlled vid a the
+#' For future assignments, lazy evaluation can be controlled via the
 #' \code{\%lazy\%} operator, e.g. \code{x \%<-\% { expr } \%lazy\% TRUE}.
 #'
 #' Until deprecated \code{plan(lazy)} is defunct, the default
@@ -132,7 +132,7 @@
 #'
 #' Specifying globals explicitly avoids the overhead added from
 #' automatically identifying the globals and gathering their values.
-#' Futhermore, if we know that the future expression does not make use
+#' Furthermore, if we know that the future expression does not make use
 #' of any global variables, we can disable the automatic search for
 #' globals by using
 #' \preformatted{

R/makeClusterPSOCK.R

@@ -66,7 +66,7 @@ makeClusterPSOCK <- function(workers, makeNode = makeNodePSOCK, port = c("auto",
 #' @param worker The host name or IP number of the machine where the worker should run.
 #' @param master The host name or IP number of the master / calling machine, as known to the workers.  If NULL (default), then the default is \code{Sys.info()[["nodename"]]} unless \code{worker} is the localhost (\code{"localhost"} or \code{"127.0.0.1"}) or \code{revtunnel = TRUE} in case it is \code{"localhost"}.
 #' @param port The port number of the master used to for communicating with all the workers (via socket connections).  If an integer vector of ports, then a random one among those is chosen.  If \code{"random"}, then a random port in \code{11000:11999} is chosen.  If \code{"auto"} (default), then the default is taken from environment variable \env{R_PARALLEL_PORT}, otherwise \code{"random"} is used.
-#' @param connectTimeout The maximum time (in seconds) allowed for each sockect connection between the master and a worker to be established (defaults to 2 minutes). \emph{See note below on current lack of support on Linux and macOS systems.}
+#' @param connectTimeout The maximum time (in seconds) allowed for each socket connection between the master and a worker to be established (defaults to 2 minutes). \emph{See note below on current lack of support on Linux and macOS systems.}
 #' @param timeout The maximum time (in seconds) allowed to pass without the master and a worker communicate with each other (defaults to 30 days).
 #' @param rscript,homogeneous The system command for launching Rscript on the worker. If \code{NULL} (default), the default is \code{"Rscript"} unless \code{homogenenous} is TRUE, which in case it is \code{file.path(R.home("bin"), "Rscript")}.  Argument \code{homogenenous} defaults to FALSE, unless \code{master} is the localhost (\code{"localhost"} or \code{"127.0.0.1"}).
 #' @param rscript_args Additional arguments to \code{Rscript} (as a character vector).
@@ -87,11 +87,11 @@ makeClusterPSOCK <- function(workers, makeNode = makeNodePSOCK, port = c("auto",
 #'         representing an established connection to a worker.
 #'
 #' @details
-#' The default is to use reverse SSH tunnelling for workers
+#' The default is to use reverse SSH tunneling for workers
 #' running on other machines.  This avoids the complication of
 #' otherwise having to configure port forwarding in firewalls,
 #' which often requires static IP address but which also most
-#' users don't have priviligies to do themselves.
+#' users don't have privileges to do themselves.
 #' It also has the advantage of not having to know the internal
 #' and / or the public IP address / host name of the master.
 #'

R/multicore.R

@@ -1,4 +1,4 @@
-#' Create a multicore future whose value will be resolved asynchroneously in a forked parallel process
+#' Create a multicore future whose value will be resolved asynchronously in a forked parallel process
 #'
 #' A multicore future is a future that uses multicore evaluation,
 #' which means that its \emph{value is computed and resolved in

R/multiprocess.R

@@ -1,4 +1,4 @@
-#' Create a multiprocess future whose value will be resolved asynchroneously using multicore or a multisession evaluation
+#' Create a multiprocess future whose value will be resolved asynchronously using multicore or a multisession evaluation
 #'
 #' A multiprocess future is a future that uses \link{multicore} evaluation
 #' if supported, otherwise it uses \link{multisession} evaluation.

R/multisession.R

@@ -1,4 +1,4 @@
-#' Create a multisession future whose value will be resolved asynchroneously in a parallel R session
+#' Create a multisession future whose value will be resolved asynchronously in a parallel R session
 #'
 #' A multisession future is a future that uses multisession evaluation,
 #' which means that its \emph{value is computed and resolved in

R/options.R

@@ -29,7 +29,7 @@
 #'  \item{\option{future.cmdargs}:}{Overrides \code{\link[base]{commandArgs}()} when the \pkg{future} package is \emph{loaded}.}
 #' }
 #'
-#' @section Options for configurating low-level system behaviors:
+#' @section Options for configuring low-level system behaviors:
 #' \describe{
 #'  \item{\option{future.availableCores.methods}:}{Default lookup methods for \code{\link{availableCores}()}. (Default: \code{c("system", "mc.cores+1", "_R_CHECK_LIMIT_CORES_", "Slurm", "PBS", "SGE")})}
 #'  \item{\option{future.availableCores.system}:}{Number of "system" cores used instead of what is reported by \code{\link{availableCores}(which="system")}. If not specified, this option is set according to system environment variable \env{R_FUTURE_AVAILABLECORES_SYSTEM} when the \pkg{future} package is \emph{loaded}.}

R/remote.R

@@ -1,4 +1,4 @@
-#' Create a remote future whose value will be resolved asynchroneously in a remote process
+#' Create a remote future whose value will be resolved asynchronously in a remote process
 #'
 #' A remote future is a future that uses remote cluster evaluation,
 #' which means that its \emph{value is computed and resolved

R/resolve.R

@@ -11,7 +11,7 @@
 #' @param idxs subset of elements to check.
 #' @param value If TRUE, the values are retrieved, otherwise not.
 #' @param recursive A non-negative number specifying how deep of
-#' a recursion should be done.  If TRUE, an infintive recursion
+#' a recursion should be done.  If TRUE, an infinite recursion
 #' is used.  If FALSE or zero, no recursion is performed.
 #' @param sleep Number of seconds to wait before checking
 #' if futures have been resolved since last time.
@@ -170,7 +170,7 @@ resolve.list <- function(x, idxs=NULL, value=FALSE, recursive=0, sleep=0.1, prog
 
       if (!is.atomic(obj)) {
         ## If an unresolved future, move on to the next object
-        ## so that future can be resolved in the asynchroneously
+        ## so that future can be resolved in the asynchronously
         if (inherits(obj, "Future")) {
           ## Lazy future that is not yet launched?
           if (obj$state == 'created') obj <- run(obj)
@@ -267,7 +267,7 @@ resolve.environment <- function(x, idxs=NULL, value=FALSE, recursive=0, sleep=0.
 
       if (!is.atomic(obj)) {
         ## If an unresolved future, move on to the next object
-        ## so that future can be resolved in the asynchroneously
+        ## so that future can be resolved in the asynchronously
         if (inherits(obj, "Future")) {
           ## Lazy future that is not yet launched?
           if (obj$state == 'created') obj <- run(obj)
@@ -364,7 +364,7 @@ resolve.listenv <- function(x, idxs=NULL, value=FALSE, recursive=0, sleep=0.1, p
 
       if (!is.atomic(obj)) {
         ## If an unresolved future, move on to the next object
-        ## so that future can be resolved in the asynchroneously
+        ## so that future can be resolved in the asynchronously
         if (inherits(obj, "Future")) {
           ## Lazy future that is not yet launched?
           if (obj$state == 'created') obj <- run(obj)

R/resolved.R

@@ -13,7 +13,7 @@
 #' the Future API.  The implementation must never throw an error,
 #' but only return either TRUE or FALSE.
 #' It should also be possible to use the method for polling the
-#' future until it is resolved (without having to wait infinitly long),
+#' future until it is resolved (without having to wait infinitely long),
 #' e.g. \code{while (!resolved(future)) Sys.sleep(5)}.
 #'
 #' @export