If you have a collection of user-defined functions written in R, it’s a good practice to compile the functionality into an R package which can then be loaded into any working session with R’s library call. This certainly beats copying and pasting the source from project to project, and makes it straightforward to share/distribute the functionality to other users and/or machines.

In this post I’ll walk through creating an R package using the devtools and roxygen2 libraries, which make the packaging process straightforward and intuitive. For our sample library, we’re going to compile a package from a collection of three functions: A Recursive Factorial function, a Combination function and a Permutation function, which will be identified as combinatronics. Here’s the contents of combinatronics.R:

```# combinatronics.R ====================================================>
#                                                                      |
#    rfactorial(n) => Compute the factorial (recursively) of `n`       |
#                     returns => int > 0                               |
#                                                                      |
#    nCr(n, r)     => Compute the combination of `n C r`: n!/k!(n-k)!  |
#                     returns => int > 0                               |
#                                                                      |
#    nPr(n, r)     => Compute the permutation of `n P r`: n!/(n-k)!    |
#                     returns => int > 0                               |
#                                                                      |
# =====================================================================>

rfactorial <- function(n) {
if (n<=1) {
return(1)
} else {
return(n*rfactorial(n-1))
}
}

nCr <- function(n, r) {

return(rfactorial(n)/(rfactorial(r)*(rfactorial(n-r))))

}

nPr <- function(n, r) {

return(rfactorial(n)/(rfactorial(n-r)))

}
```

The `devtools` library exposes the create function, which automates the setup of new source packages. Pass a directory location with the desired package name appended to create, and `devtools` will generate the required files and directories for a new source package (note that create requires that the directory doesn’t yet exist).

For example, to initialize the combinatronics library package in the `U:/Dev` folder, you’d run the following from the R interpreter:

```> create("U:/Dev/combinatronics")
```

In `U:/Dev/combinatronics`, the following directory tree is created:

```#[U:]
#   \
#  [Dev]
#      \
#    [combinatronics]
#         \
#         R                     <dir>
#         .gitignore           <file>
#         .Rbuildignore        <file>
#         combinatronics.Rproj <file>
#         DESCRIPTION          <file>
#         NAMESPACE            <file>
#
```

Populate as much information as you’d like in the DESCRIPTION file. At minimum, provide an email address so users can report bugs and/or provide feedback.

Copy the source file combinatronics.R, into the R directory created under U:/Dev/combinatronics.

Next, we’ll annotate the three functions in combinatronics.R in a way that can be parsed by `roxygen2`. After running this step, documentation will be generated that conforms to the R style, which can then be accessed like all other builtin or third-party library help files. The format is best demonstrated by example. Here’s combinatronics.R with `roxygen2` compatible function annotations:

```# combinatronics.R ====================================================>
#                                                                      |
#    rfactorial(n) => Compute the factorial (recursively) of `n`       |
#                     returns => int > 0                               |
#                                                                      |
#    nCr(n, r)     => Compute the combination of `n C r`: n!/k!(n-k)!  |
#                     returns => int > 0                               |
#                                                                      |
#    nPr(n, r)     => Compute the permutation of `n P r`: n!/(n-k)!    |
#                     returns => int > 0                               |
#                                                                      |
# =====================================================================>

#' Recursive Implementation of the Factorial Function
#'
#' Determine the product of all positive integers less than or equal to n.
#' @param n An integer to pass to the factorial function. Must be >= 0
#' @export
#' @examples
#' rfactorial(5)

rfactorial <- function(n) {
if (n<=1) {
return(1)
} else {
return(n*rfactorial(n-1))
}
}

#' Combination Function - nCr = n!/k!(n-k)!
#'
#' Returns the combination of n things taken r at a time without repetition.
#' @param n The n things
#' @param r The subgroup of r items at a time
#' @export
#' @examples
#' nCr(n=7, r=4)

nCr <- function(n, r) {

return(rfactorial(n)/(rfactorial(r)*(rfactorial(n-r))))

}

#' Permutation Function - nPr = n!/(n-k)!
#'
#' Permutation relates to the act of arranging r members of a set n into some order.
#' @param n The superset
#' @param r The r members of the set n to arrange in order
#' @export
#' @examples
#' nPr(n=7, r=4)

nPr <- function(n, r) {

return(rfactorial(n)/(rfactorial(n-r)))

}
```

After saving the annotations, call the document function from `roxygen2` to generate the documentation. We’ll need to provide the absolute path to our development directory, U:/Dev/combinatronics to `document` (typical output is listed below):

```> document("U:/Dev/combinatronics")

# output #
# Updating combinatronics documentation
# Updating roxygen version in U:\Dev\combinatronics/DESCRIPTION
# Writing NAMESPACE
# Writing rfactorial.Rd
# Writing nCr.Rd
# Writing nPr.Rd
```

`document` creates an additional directory identified as man in the combinatronics folder, which contains the compiled annotations for each of the functions in combinatronics.R. For our package, man contains rfactorial.Rd, nPr.Rd and nCr.Rd.

Finally, install the package. We need to set our working directory to the parent of our combinatronics folder (U:/Dev). Once the working directory is set, simply call `install` along with the name of the package (typical output is listed below):

```setwd("U:/Dev")
install("combinatronics")

# output =>
# Installing combinatronics
# "C:/PROGRA~1/R/R-33~1.2/bin/x64/R" --no-site-file --no-environ --no-save --no-# restore  \
#  --quiet CMD INSTALL "U:/Dev/combinatronics" --library="U:/R/win-library/3.3"  \
#  --install-tests

# * installing *source* package 'combinatronics' ...
# ** R
# ** help
# *** installing help indices
# ** building package indices
# ** testing if installed package can be loaded
# * DONE (combinatronics)
>
```

Upon completion, the interactive prompt will be returned. After importing the library, we can take a look at our package documentation in RStudio’s Help viewer. Running:

```> library(combinatronics)
> ?rfactorial
```

…will output:

Similiarly for `nCr`:

That’s it!

If you’re interested in hosting your package on GitHub, users can easily clone your work with devtools’s `install_github` function. Check out the devtools documentation for more information.

In this post we explored R package development using `devtools` and `roxygen2`. Compiling commonly-used functions into reusable code libraries eliminates unecessary duplication and reduces inconsistencies across codebases, but perhaps most importantly, we’ve demonstrated that it’s not at all difficult to do. A small investment of time upfront buys a lot of organization on the backend, especially as your project begins to scale. Happy coding!