Modernize R package

Author: coatless

DESCRIPTION

@@ -1,15 +1,22 @@
 Package: rops
 Title: Extended Binary Operators for Data Manipulation
 Version: 0.0.1
-Authors@R: person("James", "Balamuta", email = "[email protected]", role = c("aut", "cre"))
+Authors@R: c(
+        person(
+            "James Joseph", "Balamuta", 
+            email = "[email protected]",
+            role = c("aut", "cre"),
+            comment = c(ORCID = "0000-0003-2826-8458")
+        )
+    )
 Description: Provides a set of user defined infix operators and functions with
     roots in other programming languages.
 Depends:
-    R (>= 3.3.0)
+    R (>= 4.5.0)
 License: MIT + file LICENSE
 Encoding: UTF-8
 LazyData: true
-RoxygenNote: 6.0.1
+RoxygenNote: 7.3.2
 Suggests: testthat,
     knitr,
     rmarkdown,

LICENSE

@@ -1,2 +1,2 @@
-YEAR: 2016
+YEAR: 2016-2025
 COPYRIGHT HOLDER: James Joseph Balamuta

R/coalescing-ops.R

@@ -10,25 +10,34 @@
 #' @rdname null_coalesce
 #' @details
 #' The objective of the null coalescing operator is to simplify the expression:
-#' `if(is.null(x)){ y  else { x }}` so that it is readable inline.
+#'
+#' ```r
+#' if(is.null(x)) {
+#'   y
+#' else {
+#'   x
+#' }
+#' ```
+#'
+#' This allows it to be readable inline.
 #'
 #' @section Warning:
 #' Due to the way objects are created within _R_, the `NULL` value
 #' is not able to be stored within \code{\link[=vector]{atomic vectors}}.
-#' However, the \code{\link{NULL}} value can be stored within a \code{\link{list}}.
-#' This operator will _not_ be triggered if \code{\link{NULL}} is within
+#' However, the [`NULL`] value can be stored within a [`list`].
+#' This operator will _not_ be triggered if [`NULL`] is within
 #' a list! That is, the RHS side will be returned.
 #' @export
-#' @seealso \code{\link{is.null}}, \code{\link{NULL}}
+#' @seealso [`is.null()`], [`NULL`]
 #' @examples
 #' # Null value
-#' x = NULL
+#' x <- NULL
 #'
 #' # Before
-#' y = if(is.null(x)){ "Unset" } else { x }
+#' y <- if(is.null(x)){ "Unset" } else { x }
 #'
 #' # After
-#' y = x %??% "Unset"
+#' y <- x %??% "Unset"
 #'
 #' # Concrete examples without variables
 #' # Returns 3 as the LHS is _not_ NULL
@@ -46,38 +55,42 @@
 #' # Coalesce operator
 #' NULL %??% 7 %??% 8
 #' @references
-#' \url{https://en.wikipedia.org/wiki/Null_coalescing_operator}
-`%??%` = function(x, y) if(is.null(x)) y else x
+#' <https://en.wikipedia.org/wiki/Null_coalescing_operator>
+`%??%` <- function(x, y) if(is.null(x)) y else x
 
 
 #' Missingness Coalescing Operator
 #'
 #' Substitutes values when `NA` is detected.
+#'
 #' @param x An possibly containing `NA` values
 #' @param y An object of equal length or a single value to be used in
 #'          substitution
+#'
 #' @details
 #' The objective of this function is to provide an ability to substitute values
 #' for NA. However, it is important to note that _R_ is unique in the fact
 #' that it has an `NA` data type to represent missingness instead of relying
-#' on values being pre-coded (e.g. 0, -1111, et cetera). Thus, the simplicity
+#' on values being pre-coded (e.g. `0`, `-1111`, et cetera). Thus, the simplicity
 #' of this function comes with the disclaimer of:
 #'
 #' "An NA is the presence of an absence.
 #'  Don't forget that some missing values are the absence of a presence"
-#'  \href{https://twitter.com/hadleywickham/status/738802081448886272}{Hadley Wickham on Twitter}
+#'
+#' - Hadley Wickham on Twitter
+#'
 #' @export
 #' @references
-#' \url{https://support.office.com/en-us/article/IFNA-function-6626c961-a569-42fc-a49d-79b4951fd461}
+#' <https://support.office.com/en-us/article/IFNA-function-6626c961-a569-42fc-a49d-79b4951fd461>
 #' @examples
 #' # Data with missing values
-#' x = c(1, NA, NA, 4)
+#' x <- c(1, NA, NA, 4)
 #' # Substitution vector of equal length
-#' y = 1:4
+#' y <- 1:4
 #'
 #' # Replace NA with values in `y` vector
 #' ifna(x, y)
 #'
 #' # Replace NA with 5
 #' ifna(x, 5)
-ifna = function(x, y) ifelse(is.na(x), y, x)
+ifna <- function(x, y) ifelse(is.na(x), y, x)

R/equality-ops.R

@@ -4,7 +4,6 @@
 #'
 #' @param x,y two data structures
 #'
-#' @author JJB
 #' @details
 #' [base::identical()] function tests for an exact match meaning that
 #' the variable's storage types match, the overall environment the variable
@@ -21,7 +20,7 @@
 #' @examples
 #' # Generate some data
 #' set.seed(991)
-#' x = y = rnorm(100)
+#' x <- y <- rnorm(100)
 #'
 #' # Returns TRUE as the objects are exactly the same
 #' x %==% y
@@ -30,7 +29,7 @@
 #' x %!=% y
 #'
 #' # Change data
-#' x2 = x+1
+#' x2 <- x+1
 #'
 #' # Returns FALSE as the data has changed.
 #' x2 %==% y
@@ -39,11 +38,11 @@
 #' x2 %!=% y
 #' @rdname obj_check
 #' @export
-`%==%` = function(x, y) identical(x, y)
+`%==%` <- function(x, y) identical(x, y)
 
 #' @rdname obj_check
 #' @export
-`%!=%` = function(x, y) !identical(x, y)
+`%!=%` <- function(x, y) !identical(x, y)
 
 #' Not in
 #'
@@ -52,13 +51,15 @@
 #'
 #' @inheritParams base::match
 #'
-#' @return A logical vector of `TRUE` or `FALSE` that indicates if a match was
-#'         **not** found for each element of `x`.
-#' @author JJB
+#' @return
+#' A logical vector of `TRUE` or `FALSE` that indicates if a match was
+#' **not** found for each element of `x`.
+#'
 #' @details
-#' This operator is a modified version of the \code{\link[base]{\%in\%}} function.
+#' This operator is a modified version of the [`%in%`] function.
 #'
-#' @seealso \code{\link[base]{\%in\%}}
+#' @seealso
+#' [`%in%`]
 #'
 #' @examples
 #' # Returns TRUE as 2 is not found in the vector c(3, 4)
@@ -70,7 +71,7 @@
 #' # Vectorized variant that contains FALSE and TRUE
 #' c(1, 2) %notin% c(2, 3)
 #' @export
-`%notin%` = function(x, table) {
+`%notin%` <- function(x, table) {
     # Same as !(x %in% table)
     match(x, table, nomatch = 0L) == 0L
 }

R/int-ops.R

@@ -1,14 +1,14 @@
 #' Check for Whole (Integer) Numbers
 #'
-#' Checks whether the submitted vector of values is a whole (integer) number.
+#' Checks whether the submitted vector of values is a whole (`integer`) number.
 #'
-#' @param x A \code{numeric} value to check to see if it is an integer.
+#' @param x A `numeric` value to check to see if it is an `integer`.
 #'
-#' @return A \code{boolean} value indicating whether the value is an integer or not.
+#' @return
+#' A `boolean` value indicating whether the value is an `integer` or not.
 #'
-#' @author JJB
 #' @details
-#' The `is_whole` function provides a means to test whether
+#' The `is_whole()` function provides a means to test whether
 #' the [base::numeric()] or [base::integer()] is a part of the whole
 #' number span (integers). For example, `1` and `2` would be considered integers
 #' whereas `3.6` and `0.31` would be considered [base::numeric()]. The behavior
@@ -22,4 +22,6 @@
 #' is_whole(c(.4,.5,.6))
 #' is_whole(c(7,.8,9))
 #' @export
-is_whole = function(x) is.numeric(x) & floor(x) == x
+is_whole <- function(x) {
+    is.numeric(x) & floor(x) == x
+}

R/sequences.R

@@ -5,21 +5,21 @@
 #'
 #' @inheritParams base::seq
 #'
-#' @return An integer vector that is either empty or contains a sequence of
+#' @return
+#' An integer vector that is either empty or contains a sequence of
 #' numbers.
 #'
-#' @author JJB
 #' @details
-#' Creating sequences using either [base::seq()] function or \code{\link[base]{Colon}}
+#' Creating sequences using either [base::seq()] function or [`:`]
 #' operator have a notable draw back of incorrectly generating positional
 #' indices when a vector is empty. For example, consider `x = NULL`. Then,
 #' the expression `1:length(x)` would evaluate to `1:0` which expands to `c(1,0)`.
 #' As a result, any \code{\link[base]{Control}} may inadvertantly trigger an out of bounds
 #' error on the initial run.
 #'
-#' The `safe_seq()` and \code{\%:\%} operator seeks to prevent this issue by enforcing
+#' The `safe_seq()` and `%:%` operator seeks to prevent this issue by enforcing
 #' either an ascending or descending sequence depending on the `by` condition.
-#' For the \code{\%:\%} operator, note that this is restricted to being _always_
+#' For the `%:%` operator, note that this is restricted to being _always_
 #' positive.
 #' @examples
 #' # Returns a sequence increasing by 1
@@ -35,7 +35,7 @@
 #' 1 %:% 4
 #' @rdname safe_seq
 #' @export
-safe_seq = function(from = 1L,
+safe_seq <- function(from = 1L,
                     to = 1L,
                     by = 1L) {
 
@@ -66,4 +66,4 @@ safe_seq = function(from = 1L,
 
 #' @rdname safe_seq
 #' @export
-`%:%` = function(from, to) { safe_seq(from, to, by = 1L) }
+`%:%` <- function(from, to) { safe_seq(from, to, by = 1L) }