failsafe: failsafe functions that *always* return a valid object.
In j-martineau/uj: Utilities by JAM
failsafe R Documentation
failsafe functions that always return a valid object.
Description
Evaluate objects, test if an object has certain properties, and conduct binary logical operations safely. these functions never stop execution; they always produce a valid result, even if that result is an error object.
Usage
failsafe(x, def = "uj.failsafe.err")
is_err(x)
not_err(x)
msg_err(x)
make_err()
fs_def(x)
fs_nll(x)
fs_scl(x, val)
fs_t(x)
fs_f(x)
fs_tf(x)
fs_na(x)
fs_ok(x)
fs_bl(x)
fs_lg(x)
fs_vec(x, val)
fs_null(x)
scl_bl(x)
scl_t(x)
scl_f(x)
scl_tf(x)
scl_lg(x)
scl_na(x)
vec_bl(x)
vec_t(x)
vec_f(x)
vec_tf(x)
vec_na(x)
fs_or(x, or = NULL)
or_f(x)
or_t(x)
or_bl(x)
or_c0(x)
or_i0(x)
or_l0(x)
or_n0(x)
or_na(x)
or_nac(x)
or_nai(x)
or_nal(x)
or_nar(x)
or_null(x)
is_id(x, y)
not_id(x, y)
is_IN(x, ...)
is_MF(x, ...)
HAS(x, y)
LACKS(x, y)
is_EQ(x, y)
is_GE(x, y)
is_GT(x, y)
is_LE(x, y)
is_LT(x, y)
is_DIF(x, y)
is_F(x)
is_T(x)
is_BL(x)
is_TF(x)
is_NAV(x)
is_OKV(x)
is_LG(x)
is_in(x, ...)
is_mf(x, ...)
has(x, y)
not(x)
lacks(x, y)
is_eq(x, y)
is_ge(x, y)
is_gt(x, y)
is_le(x, y)
is_lt(x, y)
is_dif(x, y)
is_f(x)
is_t(x)
is_bl(x)
is_tf(x)
is_nav(x)
is_okv(x)
is_seq(x, y)
is_veq(x, y)
is_sdif(x, y)
is_vdif(x, y)
OR(x, y)
AND(x, y)
XOR(x, y)
NOR(x, y)
or(x, y)
and(x, y)
one(x, y)
nor(x, y)
not_IN(x, ...)
not_MF(x, ...)
not_HAS(x, y)
not_LACKS(x, y)
not_EQ(x, y)
not_GE(x, y)
not_GT(x, y)
not_LE(x, y)
not_LT(x, y)
not_DIF(x, y)
not_F(x)
not_T(x)
not_TF(x)
not_BL(x)
not_NAV(x)
not_OKV(x)
not_LG(x)
not_in(x, ...)
not_mf(x, ...)
not_has(x, y)
not_lacks(x, y)
not_eq(x, y)
not_ge(x, y)
not_gt(x, y)
not_le(x, y)
not_lt(x, y)
not_dif(x, y)
not_f(x)
not_t(x)
not_tf(x)
not_bl(x)
not_nav(x)
not_okv(x)
not_seq(x, y)
not_veq(x, y)
not_sdif(x, y)
not_vdif(x, y)
n_in(x, ...)
n_mf(x, ...)
n_has(x, y)
n_lacks(x, y)
n_eq(x, y)
n_ge(x, y)
n_gt(x, y)
n_le(x, y)
n_lt(x, y)
n_dif(x, y)
n_f(x)
n_t(x)
n_tf(x)
n_bl(x)
n_nav(x)
n_okv(x)
none_f(x)
none_t(x)
none_tf(x)
none_bl(x)
none_eq(x, y)
none_ge(x, y)
none_gt(x, y)
none_le(x, y)
none_lt(x, y)
none_in(x, ...)
none_mf(x, ...)
none_dif(x, y)
none_nav(x)
none_okv(x)
has_none(x, y)
lacks_none(x, y)
any_f(x)
any_t(x)
any_bl(x)
any_eq(x, y)
any_ge(x, y)
any_gt(x, y)
any_in(x, ...)
any_le(x, y)
any_lt(x, y)
any_mf(x, ...)
any_tf(x)
any_dif(x, y)
any_nav(x)
any_okv(x)
has_any(x, y)
lacks_any(x, y)
one_f(x)
one_t(x)
one_bl(x)
one_eq(x, y)
one_ge(x, y)
one_gt(x, y)
one_in(x, ...)
one_le(x, y)
one_lt(x, y)
one_mf(x, ...)
one_tf(x)
one_dif(x, y)
one_nav(x)
one_okv(x)
has_one(x, y)
lacks_one(x, y)
all_f(x)
all_t(x)
all_bl(x)
all_eq(x, y)
all_ge(x, y)
all_gt(x, y)
all_in(x, ...)
all_le(x, y)
all_lt(x, y)
all_mf(x, ...)
all_tf(x)
all_dif(x, y)
all_nav(x)
all_okv(x)
has_all(x, y)
lacks_all(x, y)
some_f(x)
some_t(x)
some_bl(x)
some_eq(x, y)
some_le(x, y)
some_ge(x, y)
some_gt(x, y)
some_in(x, ...)
some_lt(x, y)
some_mf(x, ...)
some_tf(x)
some_dif(x, y)
some_nav(x)
some_okv(x)
has_some(x, y)
lacks_some(x, y)
two_f(x)
two_t(x)
two_bl(x)
two_eq(x, y)
two_ge(x, y)
two_gt(x, y)
two_in(x, ...)
two_le(x, y)
two_lt(x, y)
two_mf(x, ...)
two_tf(x)
two_dif(x, y)
two_nav(x)
two_okv(x)
has_two(x, y)
lacks_two(x, y)
many_f(x)
many_t(x)
many_bl(x)
many_eq(x, y)
many_ge(x, y)
many_gt(x, y)
many_in(x, ...)
many_le(x, y)
many_lt(x, y)
many_mf(x, ...)
many_tf(x)
many_dif(x, y)
many_nav(x)
many_okv(x)
has_many(x, y)
lacks_many(x, y)
x %.IN.% y
x %.MF.% y
x %.EQ.% y
x %.GE.% y
x %.GT.% y
x %.LE.% y
x %.LT.% y
x %.HAS.% y
x %.DIF.% y
x %.LACKS.% y
x %.in.% y
x %.mf.% y
x %.eq.% y
x %.ge.% y
x %.gt.% y
x %.le.% y
x %.lt.% y
x %.has.% y
x %.dif.% y
x %.lacks.% y
x %.seq.% y
x %.veq.% y
x %.neq.% y
x %.sdif.% y
x %.vdif.% y
x %.ndif.% y
x %.OR.% y
x %.AND.% y
x %.XOR.% y
x %.NOR.% y
x %.or.% y
x %.and.% y
x %.xor.% y
x %.nor.% y
Arguments
def
A character scalar default error message if forcing evaluation produces an error. If not a character scalar, it is replaced with the default.
val, or, x, y
Any object/expression to be evaluated, whether or not doing so produces an error.
...
Any objects/expressions to be evaluated, whether or not doing so produces an error.
Details
Error management functions
These functions evaluate generate, check for, and manage error objects.
make_err generate object of class 'simpleError'.
msg_err get error message, if any; otherwise, NULL.
not_err Does evaluating x not produce an error?.
is_err Does evaluating x produce an error?
failsafe check for classes of objects with values
failsafe Returns x if identity evaluation does not_ cause an error. Returns
an error object otherwise with the attribute stack = uj::callers().
fs_null x is NULL.
fs_def x is defined (not NULL).
fs_scl x is scalar of a specific atomic value.
fs_t x is scalar TRUE.
fs_f x is scalar FALSE.
fs_na x is scalar NA.
fs_tf x is scalar TRUE or scalar FALSE.
scl_f x is scalar FALSE
scl_t x is scalar TRUE
scl_tf x is scalar TRUE or FALSE.
scl_lg x is scalar TRUE, FALSE, or NA.
scl_bl x is blank string scalar ("").
scl_na x is scalar NA
fs_vec Elements of x are of a specific atomic value.
vec_f Elements of x are FALSE.
vec_t Elements of x are TRUE.
vec_tf Elements of x are TRUE or FALSE.
vec_lg Elements of x are TRUE, FALSE, or NA.
vec_bl Elements of x are blank strings.
vec_na Elements of x are NA.
Forced-evaluation functions with conditional return values
These functions force evaluation of x returning values as shown in the following table with the first value returned when forcing evaluation does not produce an error and the second when it does:
fs_or x or something else if evaluating x produces an error
or_f x or FALSE
or_t x or TRUE
or_c0 x or character(0)
or_i0 x or integer(0)
or_l0 x or logical(0)
or_n0 x or numeric(0)
or_bl x or ""
or_na x or NA
or_nac x or NA_character_
or_nai x or NA_integer_
or_nal x or NA (logical)
or_nar x or NA_real_
Binary comparison functions
These are binary functions that always produce either scalar TRUE or scalar FALSE. They return TRUE when two variables meet the conditions shown in the following table and FALSE in every other circumstance (where fx and fy)
%.is.% failsafe(identical(x, y))
%.isnt.% !(x %.is.% y)
%.in.% sapply(failsafe(x %in% y), isTRUE)
%.in.% if x is atomic scalar, x %.in.% y, otherwise FALSE
%.mf.% !(x %.in.% y) (missing from)
%.has.% y %.in.% x (x has each y value)
%.lacks.% y %.mf.% x (x lacks each y value)
%.eq.% If x and y match^{(1)}, x = y, otherwise FALSE
%.ge.% If x and y match^{(1)}, x ≥ y, otherwise FALSE
%.gt.% If x and y match^{(1)}, x > y, otherwise FALSE
%.le.% If x and y match^{(1)}, x ≤ y, otherwise FALSE
%.lt.% If x and y match^{(1)}, x < y, otherwise FALSE
%.dif.% If x and y match^{(1)}, x ≠ y, otherwise TRUE
%.seq.% x and y are setequal^{(4)}
%.veq.% x and y are vector equal^{(5)}
%.sdif.% x and y are set different^{(6)}
%.vdif.% x and y are vector different^{(7)}
%.or.% values of x and/or y are TRUE
%.and.% values of x and y are TRUE
%.xor.% values of either x or y are TRUE
%.nor.% values of neither x nor y are TRUE
%.mf.% x is atomic scalar and x %.mf.% y
%.has.% y is atomic scalar and x %.has.% y
%.lacks.% y is atomic scalar and x %.lacks.% y
%.eq.% x and y are atomic scalar and x = y ^{(2)}
%.ge.% x and y are atomic scalar and x ≥ y ^{(2)}
%.gt.% x and y are atomic scalar and x > y ^{(2)}
%.le.% x and y are atomic scalar and x ≤ y ^{(2)}
%.lt.% x and y are atomic scalar and x ≥ y ^{(2)}
%.dIF.% x and y are not atomic scalar equal ^{(3)}
%.OR.% x and/or y are scalar TRUE
%.AND.% x and y are scalar TRUE
%.XOR.% either x or y is scalar TRUE
%.NOR.% neither x nor y is scalar TRUE
^{(1)} Of equal length and compatible modes.
^{(2)} Of compatible modes and meeting the (in)equality.
^{(3)} not meeting the requirements of %.eq0.%.
^{(4)} atomic, of the same length, with the same values in the same order.
^{(5)} atomic, possibly of different lengths, and containing the same unique values regardless of order or duplicates.
^{(6)} not meeting the requirements of %.seq.%.
^{(7)} not meeting the requirements of %.veq.%.
Scalar value, membership, and equality/inequality checking functions
These functions check for class, mode, and/or value and/or count the number of checks passed. they always produce TRUE, FALSE, or an integer scalar.
Function names are constructed of root words, prefixes, and/or suffixes. Root word specify the type of check conducted. Prefixes and suffixes specify how to modify the results of a check or how to apply the check to each ... argument and check whether a certain number of ... args passed the checks.
Uppercase root words indicate one or both arguments must be scalar. Lowercase root words indicate arguments may be vectors.
Root words for atomic scalar value checking functions
nav x is atomic and values are NA.
okv x is atomic and values are not NA.
bl x is atomic and values are blanks ("").
lg x is atomic and values are logical (TRUE, FALSE, or NA).
tf x is atomic and values are TRUE or FALSE.
f x is atomic and values are TRUE.
t x is atomic and valules are FALSE.
Root words for atomic value membership checking functions
lacks x lacks values of y.
has x has values of y.
in x in values of y.
mf x missing from values of y.
Root words for equality/inequality checking functions
id objects are identical
ge x is greater than or equal to y.
gt x is greater than y.
le x is less than or equal to y.
lt x is less than y.
eq values are equal
dif values are different
seq values are set equal
sdif values are set different
veq values are vector equal
vdif values are vector different
Modifier prefixes/suffixes
n count ... args passing the check.
is Keep the result of a check as is.
not Negate the result of a check.
Apply-and-sweep prefixes/suffixes evaluating whether a certain number of checks were passed
the following table contains prefixes in the first column, and in the second, the number of checks that must be passed to return TRUE.
none 0 values passed the check.
any > 0 values passed the check.
one 1 value passed the check.
some > 1 values passed the check.
two 2 values passed the check.
many > 2 values passed the check.
all all values passed the check.
Identity-equality, set-equality and vector-equality checking functions
is not
id is_id not_id
seq is_seq not_deq
veq is_veq not_veq
sdif is_sdif not_sdif
vdif is_vdif not_vdif
atomic scalar value checking functions
is not
t is_T not_T
f is_F not_F
tf is_TF not_TF
lg is_LG not_LG
bl is_BL not_BL
eq is_EQ not_EQ
ge is_GE not_GE
gt is_GT not_GT
le is_LE not_LE
lt is_LT not_LT
nav is_NAV not_NAV
okv is_OKV not_OKV
dif is_DIF not_DIF
atomic scalar value membership checking functions
is not
in is_IN not_IN
mf is_MF not_MF
has HAS not_HAS
lacks LACKS not_LACKS
atomic value checking functions
is n not none one two any some many all_
t is_t n_t not_t none_t one_t two_t any_t some_t many_t all_t
f is_f n_f not_f none_f one_f two_f any_f some_f many_f all_f
tf is_tf n_tf not_tf none_tf one_tf two_tf any_tf some_tf many_tf all_tf
bl is_bl n_bl not_bl none_bl one_bl two_bl any_bl some_bl many_bl all_bl
eq is_eq n_eq not_eq none_eq one_eq two_eq any_eq some_eq many_eq all_eq
ge is_ge n_ge not_ge none_ge one_ge two_ge any_ge some_ge many_ge all_ge
gt is_gt n_gt not_gt none_gt one_gt two_gt any_gt some_gt many_gt all_gt
le is_le n_le not_le none_le one_le two_le any_le some_le many_le all_le
lt is_lt n_lt not_lt none_lt one_lt two_lt any_lt some_lt many_lt all_lt
dif is_dif n_dif not_dif none_dif one_dif two_dif any_dif some_dif many_dif all_dif
nav is_nav n_nav not_nav none_nav one_nav two_nav any_nav some_nav many_nav all_nav
okv is_okv n_okv not_okv none_okv one_okv two_okv any_okv some_okv many_okv all_okv
atomic value membership checking functions
is n not none one two any some many all
in is_in n_in not_in in_none in_one in_two in_any in_some in_many in_all
mf is_mf n_mf not_mf mf_none mf_one mf_two mf_any mf_some mf_many mf_all
has has n_has not_has has_none has_one has_two has_any has_some has_many has_all
lacks locks n_lacks not_lacks lacks_none lacks_one lacks_two lacks_any lacks_some lacks_many lacks_all
Value
A logical scalar or vector.
Examples
egfailsafe <- function() {
abc <- c("a", "b", "c")
abc <- abc
blank <- ""
mss.scl <- Na
lgl.scl <- FALSE
fac.scl <- factor("q", levels = c("x", "q"))
fac.vec <- factor(c("x", "q"), levels = c("x", "q"))
chr.mat <- matrix(c("a", "b", "c", "Na"), nrow = 2)
chr.dtf <- data.frame(abc = letters[1:3], def = letters[4:6])
num.vls <- list(first3 = c(1:3, NA), next3 = c(4:6, NA))
combo <- list(mss.scl, lgl.scl, fac.vec, chr.mat, chr.dtf, numvls)
attr(abc, "custom") <- "custom"
list(`"a" %.AND.% FALSE` = "a" %.AND.% FALSE ,
`"a" %.in.% abc` = "a" %.in.% abc ,
`"a" %.NOR.% FALSE` = "a" %.OR.% FALSE ,
`"a" %.XOR.% FALSE` = "a" %.XOR.% FALSE ,
`"a" %.OR.% FALSE` = "a" %.OR.% FALSE ,
`"a" %.mf.% abc` = "a" %.mf.% abc ,
`"a" %.and.% FALSE` = "a" %.and.% FALSE ,
`"a" %.in.% abc` = "a" %.in.% abc ,
`"a" %.nor.% FALSE` = "a" %.or.% FALSE ,
`"a" %.xor.% FALSE` = "a" %.xor.% FALSE ,
`"a" %.or.% FALSE` = "a" %.or.% FALSE ,
`"a" %.mf.% abc` = "a" %.mf.% abc ,
`1 %.in.% abc` = 1 %.in.% abc ,
`1 %.mf.% abc` = 1 %.mf.% abc ,
`abc %.EQ.% abc` = abc %.EQ.% abc ,
`abc %.eq.% letters[1:3]` = abc %.eq.% letters[1:3] ,
`abc %.eq.% NULL` = abc %.eq.% NULL ,
`abc %.HAS.% "a"` = abc %.HAS.% "a" ,
`abc %.HAS.% 1` = abc %.HAS.% 1 ,
`abc %.HAS.% NULL` = abc %.HAS.% NULL ,
`abc %.has.% letters[1:6]` = abc %.has.% "a" ,
`abc %.has.% 1:3` = abc %.has.% 1 ,
`abc %.has.% NULL` = abc %.has.% NULL ,
`abc %.is.% NULL` = abc %.is.% NULL ,
`abc %.lacks.% "a"` = abc %.lacks.% "a" ,
`abc %.lacks.% 1` = abc %.lacks.% 1 ,
`abc %.lacks.% NULL` = abc %.lacks.% NULL ,
`abc %.is.% abc` = abc %.is.% abc ,
`abc %.is.% letters[1:3]` = abc %.is.% letters[1:3] ,
`abc %.isnt.% abc` = abc %.isnt.% abc ,
`abc %.isnt.% letters[4:6]` = abc %.isnt.% letters[4:6] ,
`all_bl(c(blank, letters))` = all_bl(c(blank, letters)) ,
`all_dif("a", c(blank, NA, letters))` = all_dif("a", c(blank, NA, letters)) ,
`all_eq(NA, c(blank, NA, letters))` = all_eq(NA, c(blank, NA, letters)) ,
`all_f(c(list(blank), combo))` = all_f(c(list(blank), combo)) ,
`all_ge("a", c(blank, NA, letters))` = all_ge("a", c(blank, NA, letters)) ,
`all_gt("a", c(blank, NA, letters))` = all_gt("a", c(blank, NA, letters)) ,
`all_in(NULL, blank, combo)` = all_in(NULL, blank, combo) ,
`all_le("a", c(blank, NA, letters))` = all_le("a", c(blank, NA, letters)) ,
`all_lg(c(NA, TRUE, FALSE))` = all_lg(c(NA, TRUE, FALSE)) ,
`all_lt("a", c(blank, NA, letters))` = all_lt("a", c(blank, NA, letters)) ,
`all_mf(NULL, blank, combo)` = all_mf(NULL, blank, combo) ,
`all_nav(c(blank, NA, letters))` = all_nav(c(blank, NA, letters)) ,
`all_nav(chr.mat)` = all_nav(chr.mat) ,
`all_okv(c(blank, NA, letters))` = all_okv(c(blank, NA, letters)) ,
`all_okv(chr.mat)` = all_okv(chr.mat) ,
`all_t(c(list(blank), combo))` = all_t(c(list(blank), combo)) ,
`all_tf(c(list(blank), combo))` = all_tf(c(list(blank), combo)) ,
`any_bl(c(blank, letters))` = any_bl(c(blank, letters)) ,
`any_dif("a", c(blank, NA, letters))` = any_dif("a", c(blank, NA, letters)) ,
`any_eq(NA, c(blank, NA, letters))` = any_eq(NA, c(blank, NA, letters)) ,
`any_f(c(list(blank), combo))` = any_f(c(list(blank), combo)) ,
`any_ge("a", c(blank, NA, letters))` = any_ge("a", c(blank, NA, letters)) ,
`any_gt("a", c(blank, NA, letters))` = any_gt("a", c(blank, NA, letters)) ,
`any_in(NULL, blank, combo)` = any_in(NULL, blank, combo) ,
`any_le("a", c(blank, NA, letters))` = any_le("a", c(blank, NA, letters)) ,
`any_lg(c(NA, TRUE, FALSE))` = any_lg(c(NA, TRUE, FALSE)) ,
`any_lt("a", c(blank, NA, letters))` = any_lt("a", c(blank, NA, letters)) ,
`any_mf(NULL, blank, combo)` = any_mf(NULL, blank, combo) ,
`any_nav(c(blank, NA, letters))` = any_nav(c(blank, NA, letters)) ,
`any_nav(chr.mat)` = any_nav(chr.mat) ,
`any_okv(c(blank, NA, letters))` = any_okv(c(blank, NA, letters)) ,
`any_okv(chr.mat)` = any_okv(chr.mat) ,
`any_t(c(list(blank), combo))` = any_t(c(list(blank), combo)) ,
`any_tf(c(list(blank), combo))` = any_tf(c(list(blank), combo)) ,
`failsafe(non.existent.variable)` = failsafe(non.existent.variable) ,
`failsafe(pi)` = failsafe(pi) ,
`FALSE %.and.% FALSE` = FALSE %.and.% FALSE ,
`FALSE %.nor.% FALSE` = FALSE %.nor.% FALSE ,
`FALSE %.xor.% FALSE` = FALSE %.xor.% FALSE ,
`FALSE %.or.% FALSE` = FALSE %.or.% FALSE ,
`has_all(blank, combo)` = has_all(blank, combo) ,
`has_any(blank, combo)` = has_any(blank, combo) ,
`has_many(blank, combo)` = has_many(blank, combo) ,
`has_none(blank, combo)` = has_none(blank, combo) ,
`has_one(blank, combo)` = has_one(blank, combo) ,
`has_some(blank, combo)` = has_some(blank, combo) ,
`has_two(blank, combo)` = has_two(blank, combo) ,
`is_bl("")` = is_bl("") ,
`is_bl("a")` = is_bl("a") ,
`is_bl(c("", ""))` = is_bl(c("", "")) ,
`is_bl(NA)` = is_bl(NA) ,
`is_BL("")` = is_BL("") ,
`is_BL("a")` = is_BL("a") ,
`is_BL(c("", ""))` = is_BL(c("", "")) ,
`is_BL(NA)` = is_BL(NA) ,
`is_dif("", "")` = is_dif("", "") ,
`is_dif("word", 7)` = is_dif("word", 7) ,
`is_dif(chr.mat, chr.mat)` = is_dif(chr.mat, chr.mat) ,
`is_dif(NA, NA)` = is_dif(NA, NA) ,
`is_DIF("", "")` = is_DIF("", "") ,
`is_DIF("word", 7)` = is_DIF("word", 7) ,
`is_DIF(chr.mat, chr.mat)` = is_DIF(chr.mat, chr.mat) ,
`is_DIF(NA, NA)` = is_DIF(NA, NA) ,
`is_eq("", "")` = is_eq("", "") ,
`is_eq("word", 7)` = is_eq("word", 7) ,
`is_eq(chr.mat, chr.mat)` = is_eq(chr.mat, chr.mat) ,
`is_eq(NA, NA)` = is_eq(NA, NA) ,
`is_EQ("", "")` = is_EQ("", "") ,
`is_EQ("word", 7)` = is_EQ("word", 7) ,
`is_EQ(chr.mat, chr.mat)` = is_EQ(chr.mat, chr.mat) ,
`is_EQ(NA, NA)` = is_EQ(NA, NA) ,
`is_err(non.existent.variable)` = is_err(non.existent.variable) ,
`is_err(pi)` = is_err(pi) ,
`is_f(c(TRUE, FALSE))` = is_f(c(TRUE, FALSE)) ,
`is_f(chr.mat)` = is_f(chr.mat) ,
`is_f(NA)` = is_f(NA) ,
`is_f(TRUE)` = is_f(TRUE) ,
`is_f(TRUE)` = is_f(TRUE) ,
`is_F(c(TRUE, FALSE))` = is_F(c(TRUE, FALSE)) ,
`is_F(chr.mat)` = is_F(chr.mat) ,
`is_F(FALSE)` = is_F(FALSE) ,
`is_F(NA)` = is_F(NA) ,
`is_F(TRUE)` = is_F(TRUE) ,
`is_ge("a", "b")` = is_ge("a", "b") ,
`is_ge("b", "a")` = is_ge("b", "a") ,
`is_ge(1, 1)` = is_ge(1, 1) ,
`is_ge(chr.mat, chr.mat)` = is_ge(chr.mat, chr.mat) ,
`is_GE("a", "b")` = is_GE("a", "b") ,
`is_GE("b", "a")` = is_GE("b", "a") ,
`is_GE(1, 1)` = is_GE(1, 1) ,
`is_GE(chr.mat, chr.mat)` = is_GE(chr.mat, chr.mat) ,
`is_gt("a", "b")` = is_gt("a", "b") ,
`is_gt("b", "a")` = is_gt("b", "a") ,
`is_gt(1, 1)` = is_gt(1, 1) ,
`is_gt(chr.mat, chr.mat)` = is_gt(chr.mat, chr.mat) ,
`is_GT("a", "b")` = is_GT("a", "b") ,
`is_GT("b", "a")` = is_GT("b", "a") ,
`is_GT(1, 1)` = is_GT(1, 1) ,
`is_GT(chr.mat, chr.mat)` = is_GT(chr.mat, chr.mat) ,
`is_in(1, "", "a", 1:2)` = is_in(1, "", "a", 1:2) ,
`is_in(1, "a", letters)` = is_in(1, "a", letters) ,
`is_in(NULL, blank, combo)` = is_in(NULL, blank, combo) ,
`is_IN(1, "", "a", 1:2)` = is_IN(1, "", "a", 1:2) ,
`is_IN(1, "a", letters)` = is_IN(1, "a", letters) ,
`is_IN(NULL, blank, combo)` = is_IN(NULL, blank, combo) ,
`is_BL(chr.mat)` = is_BL(chr.mat) ,
`is_le("a", "b")` = is_le("a", "b") ,
`is_le("b", "a")` = is_le("b", "a") ,
`is_le(1, 1)` = is_le(1, 1) ,
`is_le(chr.mat, chr.mat)` = is_le(chr.mat, chr.mat) ,
`is_LE("a", "b")` = is_LE("a", "b") ,
`is_LE("b", "a")` = is_LE("b", "a") ,
`is_LE(1, 1)` = is_LE(1, 1) ,
`is_LE(chr.mat, chr.mat)` = is_LE(chr.mat, chr.mat) ,
`is_LG(c(TRUE, FALSE))` = is_LG(c(TRUE, FALSE)) ,
`is_LG(chr.mat)` = is_LG(chr.mat) ,
`is_LG(FALSE)` = is_LG(FALSE) ,
`is_LG(NA)` = is_LG(NA) ,
`is_LG(TRUE)` = is_LG(TRUE) ,
`is_lt("a", "b")` = is_lt("a", "b") ,
`is_lt("b", "a")` = is_lt("b", "a") ,
`is_lt(1, 1)` = is_lt(1, 1) ,
`is_lt(chr.mat, chr.mat)` = is_lt(chr.mat, chr.mat) ,
`is_LT("a", "b")` = is_LT("a", "b") ,
`is_LT("b", "a")` = is_LT("b", "a") ,
`is_LT(1, 1)` = is_LT(1, 1) ,
`is_LT(chr.mat, chr.mat)` = is_LT(chr.mat, chr.mat) ,
`is_mf(1, "", "a", 1:2)` = is_mf(1, "", "a", 1:2) ,
`is_mf(1, "a", letters)` = is_mf(1, "a", letters) ,
`is_mf(NULL, blank, combo)` = is_mf(NULL, blank, combo) ,
`is_MF(1, "", "a", 1:2)` = is_MF(1, "", "a", 1:2) ,
`is_MF(1, "a", letters)` = is_MF(1, "a", letters) ,
`is_MF(NULL, blank, combo)` = is_MF(NULL, blank, combo) ,
`is_nav(1)` = is_nav(1) ,
`is_nav(c(NA, NA))` = is_nav(c(NA, NA)) ,
`is_nav(chr.mat)` = is_nav(chr.mat) ,
`is_nav(NA)` = is_nav(NA) ,
`is_NAV(1)` = is_NAV(1) ,
`is_NAV(c(NA, NA))` = is_NAV(c(NA, NA)) ,
`is_NAV(chr.mat)` = is_NAV(chr.mat) ,
`is_NAV(NA)` = is_NAV(NA) ,
`is_okv(1)` = is_okv(1) ,
`is_okv(c(NA, NA))` = is_okv(c(NA, NA)) ,
`is_okv(chr.mat)` = is_ok(chr.mat) ,
`is_okv(NA)` = is_okv(NA) ,
`is_OKV(1)` = is_OKV(1) ,
`is_OKV(c(NA, NA))` = is_OKV(c(NA, NA)) ,
`is_OKV(chr.mat)` = is_OKV(chr.mat) ,
`is_OKV(NA)` = is_OKV(NA) ,
`is_seq(1, letters)` = is_seq(1, letters) ,
`is_seq(1, letters)` = is_seq(1, letters) ,
`is_seq(1:3, c(1, 2, 3, 2, 1))` = is_seq(1:3, c(1, 2, 3, 2, 1)) ,
`is_seq(1:3, c(1, 2, 3, 2, 1))` = is_seq(1:3, c(1, 2, 3, 2, 1)) ,
`is_seq(1:3, c(1, 2, 3))` = is_seq(1:3, c(1, 2, 3)) ,
`is_seq(1:3, c(1, 2, 3))` = is_seq(1:3, c(1, 2, 3)) ,
`is_t(c(TRUE, FALSE))` = is_t(c(TRUE, FALSE)) ,
`is_t(chr.mat)` = is_t(chr.mat) ,
`is_t(NA)` = is_t(NA) ,
`is_t(TRUE)` = is_t(TRUE) ,
`is_t(TRUE)` = is_t(TRUE) ,
`is_T(c(TRUE, FALSE))` = is_T(c(TRUE, FALSE)) ,
`is_T(chr.mat)` = is_T(chr.mat) ,
`is_T(FALSE)` = is_T(FALSE) ,
`is_T(NA)` = is_T(NA) ,
`is_T(TRUE)` = is_T(TRUE) ,
`is_tf(c(TRUE, FALSE))` = is_tf(c(TRUE, FALSE)) ,
`is_tf(chr.mat)` = is_tf(chr.mat) ,
`is_tf(chr.mat)` = is_tf(chr.mat) ,
`is_tf(NA)` = is_tf(NA) ,
`is_tf(TRUE)` = is_tf(TRUE) ,
`is_tf(TRUE)` = is_tf(TRUE) ,
`is_TF(c(TRUE, FALSE))` = is_TF(c(TRUE, FALSE)) ,
`is_TF(chr.mat)` = is_TF(chr.mat) ,
`is_TF(FALSE)` = is_TF(FALSE) ,
`is_TF(NA)` = is_TF(NA) ,
`is_TF(TRUE)` = is_TF(TRUE) ,
`is_veq(1, letters)` = is_veq(1, letters) ,
`is_veq(1:3, c(1, 2, 3, 2, 1))` = is_veq(1:3, c(1, 2, 3, 2, 1)) ,
`is_veq(1:3, c(1, 2, 3, 2, 1))` = is_veq(1:3, c(1, 2, 3, 2, 1)) ,
`is_veq(1:3, letters)` = is_veq(1:3, letters) ,
`is_veq(1:3, c(1, 2, 3))` = is_veq(1:3, c(1, 2, 3)) ,
`is_veq(1:3, c(1, 2, 3))` = is_veq(1:3, c(1, 2, 3)) ,
`lacks_all(blank, combo)` = lacks_all(blank, combo) ,
`lacks_any(blank, combo)` = lacks_any(blank, combo) ,
`lacks_many(blank, combo)` = lacks_many(blank, combo) ,
`lacks_none(blank, combo)` = lacks_none(blank, combo) ,
`lacks_one(blank, combo)` = lacks_one(blank, combo) ,
`lacks_some(blank, combo)` = lacks_some(blank, combo) ,
`lacks_two(blank, combo)` = lacks_two(blank, combo) ,
`many_bl(c(blank, letters))` = many_bl(c(blank, letters)) ,
`many_dif("a", c(blank, NA, letters))` = many_dif("a", c(blank, NA, letters)),
`many_eq(NA, c(blank, NA, letters))` = many_eq(NA, c(blank, NA, letters)) ,
`many_f(c(list(blank), combo))` = many_f(c(list(blank), combo)) ,
`many_ge("a", c(blank, NA, letters))` = many_ge("a", c(blank, NA, letters)) ,
`many_gt("a", c(blank, NA, letters))` = many_gt("a", c(blank, NA, letters)) ,
`many_in(NULL, blank, combo)` = many_in(NULL, blank, combo) ,
`many_le("a", c(blank, NA, letters))` = many_le("a", c(blank, NA, letters)) ,
`many_lg(c(NA, TRUE, FALSE))` = many_lg(c(NA, TRUE, FALSE)) ,
`many_lt("a", c(blank, NA, letters))` = many_lt("a", c(blank, NA, letters)) ,
`many_mf(NULL, blank, combo)` = many_mf(NULL, blank, combo) ,
`many_nav(c(blank, NA, letters))` = many_nav(c(blank, NA, letters)) ,
`many_nav(chr.mat)` = many_nav(chr.mat) ,
`many_okv(c(blank, NA, letters))` = many_okv(c(blank, NA, letters)) ,
`many_okv(chr.mat)` = many_okv(chr.mat) ,
`many_t(c(list(blank), combo))` = many_t(c(list(blank), combo)) ,
`many_tf(c(list(blank), combo))` = many_tf(c(list(blank), combo)) ,
`msg_err(non.existent.variable)` = msg_err(non.existent.variable) ,
`msg_err(pi)` = msg_err(pi) ,
`n_bl(c(list(blank), combo))` = n_bl(c(list(blank), combo)) ,
`n_f(c(list(blank), combo))` = n_f(c(list(blank), combo)) ,
`n_has(blank, combo)` = n_has(blank, combo) ,
`n_in(NULL, blank, combo)` = n_in(NULL, blank, combo) ,
`n_lacks(blank, combo)` = n_lacks(blank, combo) ,
`n_mf(NULL, blank, combo)` = n_mf(NULL, blank, combo) ,
`n_nav(chr.mat)` = n_nav(chr.mat) ,
`n_okv(chr.mat)` = n_okv(chr.mat) ,
`none_bl(c(blank, letters))` = none_bl(c(blank, letters)) ,
`none_dif("a", c(blank, NA, letters))` = none_dif("a", c(blank, NA, letters)),
`none_eq(NA, c(blank, NA, letters))` = none_eq(NA, c(blank, NA, letters)) ,
`none_f(c(list(blank), combo))` = none_f(c(list(blank), combo)) ,
`none_ge("a", c(blank, NA, letters))` = none_ge("a", c(blank, NA, letters)) ,
`none_gt("a", c(blank, NA, letters))` = none_gt("a", c(blank, NA, letters)) ,
`none_in(NULL, blank, combo)` = none_in(NULL, blank, combo) ,
`none_le("a", c(blank, NA, letters))` = none_le("a", c(blank, NA, letters)) ,
`none_lg(c(NA, TRUE, FALSE))` = none_lg(c(NA, TRUE, FALSE)) ,
`none_lt("a", c(blank, NA, letters))` = none_lt("a", c(blank, NA, letters)) ,
`none_mf(NULL, blank, combo)` = none_mf(NULL, blank, combo) ,
`none_nav(c(blank, NA, letters))` = none_nav(c(blank, NA, letters)) ,
`none_nav(chr.mat)` = none_nav(chr.mat) ,
`none_okv(c(blank, NA, letters))` = none_okv(c(blank, NA, letters)) ,
`none_okv(chr.mat)` = none_okv(chr.mat) ,
`none_t(c(list(blank), combo))` = none_t(c(list(blank), combo)) ,
`none_tf(c(list(blank), combo))` = none_tf(c(list(blank), combo)) ,
`not_bl("")` = not_bl("") ,
`not_bl("a")` = not_bl("a") ,
`not_bl(c("", ""))` = not_bl(c("", "")) ,
`not_bl(chr.mat)` = not_bl(chr.mat) ,
`not_bl(NA)` = not_bl(NA) ,
`not_BL("")` = not_BL("") ,
`not_BL("a")` = not_BL("a") ,
`not_BL(c("", ""))` = not_BL(c("", "")) ,
`not_BL(chr.mat)` = not_BL(chr.mat) ,
`not_BL(NA)` = not_BL(NA) ,
`not_dif("", "")` = not_dif("", "") ,
`not_dif("word", 7)` = not_dif("word", 7) ,
`not_dif(chr.mat, chr.mat)` = not_dif(chr.mat, chr.mat) ,
`not_dif(NA, NA)` = not_dif(NA, NA) ,
`not_DIF("", "")` = not_DIF("", "") ,
`not_DIF("word", 7)` = not_DIF("word", 7) ,
`not_DIF(chr.mat, chr.mat)` = not_DIF(chr.mat, chr.mat) ,
`not_DIF(NA, NA)` = not_DIF(NA, NA) ,
`not_eq("", "")` = not_eq("", "") ,
`not_eq("word", 7)` = not_eq("word", 7) ,
`not_eq(chr.mat, chr.mat)` = not_eq(chr.mat, chr.mat) ,
`not_eq(NA, NA)` = not_eq(NA, NA) ,
`not_EQ("", "")` = not_EQ("", "") ,
`not_EQ("word", 7)` = not_EQ("word", 7) ,
`not_EQ(chr.mat, chr.mat)` = not_EQ(chr.mat, chr.mat) ,
`not_EQ(NA, NA)` = not_EQ(NA, NA) ,
`not_err(non.existent.variable)` = not_err(non.existent.variable) ,
`not_err(pi)` = not_err(pi) ,
`not_f(c(TRUE, FALSE))` = not_f(c(TRUE, FALSE)) ,
`not_f(chr.mat)` = not_f(chr.mat) ,
`not_f(NA)` = not_f(NA) ,
`not_f(TRUE)` = not_f(TRUE) ,
`not_f(TRUE)` = not_f(TRUE) ,
`not_F(c(TRUE, FALSE))` = not_F(c(TRUE, FALSE)) ,
`not_F(chr.mat)` = not_F(chr.mat) ,
`not_F(FALSE)` = not_F(FALSE) ,
`not_F(NA)` = not_F(NA) ,
`not_F(TRUE)` = not_F(TRUE) ,
`not_ge("a", "b")` = not_ge("a", "b") ,
`not_ge("b", "a")` = not_ge("b", "a") ,
`not_ge(1, 1)` = not_ge(1, 1) ,
`not_ge(chr.mat, chr.mat)` = not_ge(chr.mat, chr.mat) ,
`not_GE("a", "b")` = not_GE("a", "b") ,
`not_GE("b", "a")` = not_GE("b", "a") ,
`not_GE(1, 1)` = not_GE(1, 1) ,
`not_GE(chr.mat, chr.mat)` = not_GE(chr.mat, chr.mat) ,
`not_gt("a", "b")` = not_gt("a", "b") ,
`not_gt("b", "a")` = not_gt("b", "a") ,
`not_gt(1, 1)` = not_gt(1, 1) ,
`not_gt(chr.mat, chr.mat)` = not_gt(chr.mat, chr.mat) ,
`not_GT("a", "b")` = not_GT("a", "b") ,
`not_GT("b", "a")` = not_GT("b", "a") ,
`not_GT(1, 1)` = not_GT(1, 1) ,
`not_GT(chr.mat, chr.mat)` = not_GT(chr.mat, chr.mat) ,
`not_in(1, "", "a", 1:2)` = not_in(1, "", "a", 1:2) ,
`not_in(1, "a", letters)` = not_in(1, "a", letters) ,
`not_in(NULL, blank, combo)` = not_in(NULL, blank, combo) ,
`not_IN(1, "", "a", 1:2)` = not_IN(1, "", "a", 1:2) ,
`not_IN(1, "a", letters)` = not_IN(1, "a", letters) ,
`not_IN(NULL, blank, combo)` = not_IN(NULL, blank, combo) ,
`not_le("a", "b")` = not_le("a", "b") ,
`not_le("b", "a")` = not_le("b", "a") ,
`not_le(1, 1)` = not_le(1, 1) ,
`not_le(chr.mat, chr.mat)` = not_le(chr.mat, chr.mat) ,
`not_LE("a", "b")` = not_LE("a", "b") ,
`not_LE("b", "a")` = not_LE("b", "a") ,
`not_LE(1, 1)` = not_LE(1, 1) ,
`not_LE(chr.mat, chr.mat)` = not_LE(chr.mat, chr.mat) ,
`not_LG(c(TRUE, FALSE))` = not_LG(c(TRUE, FALSE)) ,
`not_LG(chr.mat)` = not_LG(chr.mat) ,
`not_LG(FALSE)` = not_LG(FALSE) ,
`not_LG(NA)` = not_LG(NA) ,
`not_LG(TRUE)` = not_LG(TRUE) ,
`not_lt("a", "b")` = not_lt("a", "b") ,
`not_lt("b", "a")` = not_lt("b", "a") ,
`not_lt(1, 1)` = not_lt(1, 1) ,
`not_lt(chr.mat, chr.mat)` = not_lt(chr.mat, chr.mat) ,
`not_LT("a", "b")` = not_LT("a", "b") ,
`not_LT("b", "a")` = not_LT("b", "a") ,
`not_LT(1, 1)` = not_LT(1, 1) ,
`not_LT(chr.mat, chr.mat)` = not_LT(chr.mat, chr.mat) ,
`not_mf(1, "", "a", 1:2)` = not_mf(1, "", "a", 1:2) ,
`not_mf(1, "a", letters)` = not_mf(1, "a", letters) ,
`not_mf(NULL, blank, combo)` = not_mf(NULL, blank, combo) ,
`not_MF(1, "", "a", 1:2)` = not_MF(1, "", "a", 1:2) ,
`not_MF(1, "a", letters)` = not_MF(1, "a", letters) ,
`not_MF(NULL, blank, combo)` = not_MF(NULL, blank, combo) ,
`not_NAV(1)` = not_NAV(1) ,
`not_NAV(c(NA, NA))` = not_NAV(c(NA, NA)) ,
`not_NAV(chr.mat)` = not_NAV(chr.mat) ,
`not_NAV(NA)` = not_NAV(NA) ,
`not_nav(c(NA, NA), chr.mat)` = not_nav(c(NA, NA), chr.mat) ,
`not_nav(NA), not_nav(1)` = not_nav(NA), not_nav(1) ,
`not_OKV(1)` = not_OKV(1) ,
`not_OKV(c(NA, NA))` = not_OKV(c(NA, NA)) ,
`not_OKV(chr.mat)` = not_OKV(chr.mat) ,
`not_OKV(NA)` = not_OKV(NA) ,
`not_okv(c(NA, NA)` = not_okv(c(NA, NA)) ,
`not_okv(chr.mat)` = not_okv(chr.mat) ,
`not_okv(NA)` = not_okv(NA) ,
`not_okv(1)` = not_okv(1) ,
`not_seq(1, letters)` = not_seq(1, letters) ,
`not_seq(1, letters)` = not_seq(1, letters) ,
`not_seq(1:3, c(1, 2, 3, 2, 1))` = not_seq(1:3, c(1, 2, 3, 2, 1)) ,
`not_seq(1:3, c(1, 2, 3, 2, 1))` = not_seq(1:3, c(1, 2, 3, 2, 1)) ,
`not_seq(1:3, c(1, 2, 3))` = not_seq(1:3, c(1, 2, 3)) ,
`not_seq(1:3, c(1, 2, 3))` = not_seq(1:3, c(1, 2, 3)) ,
`not_t(c(TRUE, FALSE))` = not_t(c(TRUE, FALSE)) ,
`not_t(chr.mat)` = not_t(chr.mat) ,
`not_t(NA)` = not_t(NA) ,
`not_t(TRUE)` = not_t(TRUE) ,
`not_t(TRUE)` = not_t(TRUE) ,
`not_T(c(TRUE, FALSE))` = not_T(c(TRUE, FALSE)) ,
`not_T(chr.mat)` = not_T(chr.mat) ,
`not_T(FALSE)` = not_T(FALSE) ,
`not_T(NA)` = not_T(NA) ,
`not_T(TRUE)` = not_T(TRUE) ,
`not_tf(c(TRUE, FALSE))` = not_tf(c(TRUE, FALSE)) ,
`not_tf(chr.mat)` = not_tf(chr.mat) ,
`not_tf(NA)` = not_tf(NA) ,
`not_tf(TRUE)` = not_tf(TRUE) ,
`not_tf(TRUE)` = not_tf(TRUE) ,
`not_TF(c(TRUE, FALSE))` = not_TF(c(TRUE, FALSE)) ,
`not_TF(chr.mat)` = not_TF(chr.mat) ,
`not_TF(FALSE)` = not_TF(FALSE) ,
`not_TF(NA)` = not_TF(NA) ,
`not_TF(TRUE)` = not_TF(TRUE) ,
`not_veq(1, letters)` = not_veq(1, letters) ,
`not_veq(1, letters)` = not_veq(1, letters) ,
`not_veq(1:3, c(1, 2, 3, 2, 1))` = not_veq(1:3, c(1, 2, 3, 2, 1)) ,
`not_veq(1:3, c(1, 2, 3, 2, 1))` = not_veq(1:3, c(1, 2, 3, 2, 1)) ,
`not_veq(1:3, c(1, 2, 3))` = not_veq(1:3, c(1, 2, 3)) ,
`not_veq(1:3, c(1, 2, 3))` = not_veq(1:3, c(1, 2, 3)) ,
`n_t(c(list(blank), combo))` = n_t(c(list(blank), combo)) ,
`n_tf(c(list(blank), combo))` = n_tf(c(list(blank), combo)) ,
`NULL %.in.% abc` = NULL %.in% abc ,
`NULL %.mf.% abc` = NULL %.mf.% abc ,
`one_bl(c(blank, letters))` = one_bl(c(blank, letters)) ,
`one_dif("a", c(blank, NA, letters))` = one_dif("a", c(blank, NA, letters)) ,
`one_eq(NA, c(blank, NA, letters))` = one_eq(NA, c(blank, NA, letters)) ,
`one_f(c(list(blank), combo))` = one_f(c(list(blank), combo)) ,
`one_ge("a", c(blank, NA, letters))` = one_ge("a", c(blank, NA, letters)) ,
`one_gt("a", c(blank, NA, letters))` = one_gt("a", c(blank, NA, letters)) ,
`one_in(NULL, blank, combo)` = one_in(NULL, blank, combo) ,
`one_le("a", c(blank, NA, letters))` = one_le("a", c(blank, NA, letters)) ,
`one_lt("a", c(blank, NA, letters))` = one_lt("a", c(blank, NA, letters)) ,
`one_mf(NULL, blank, combo)` = one_mf(NULL, blank, combo) ,
`one_nav(c(blank, NA, letters))` = one_nav(c(blank, NA, letters)) ,
`one_nav(chr.mat)` = one_nav(chr.mat) ,
`one_okv(c(blank, NA, letters))` = one_okv(c(blank, NA, letters)) ,
`one_okv(chr.mat)` = one_okv(chr.mat) ,
`one_t(c(list(blank), combo))` = one_t(c(list(blank), combo)) ,
`one_tf(c(list(blank), combo))` = one_tf(c(list(blank), combo)) ,
`some_bl(c(blank, letters))` = some_bl(c(blank, letters)) ,
`some_dif("a", c(blank, NA, letters))` = some_dif("a", c(blank, NA, letters)),
`some_eq(NA, c(blank, NA, letters))` = some_eq(NA, c(blank, NA, letters)) ,
`some_f(c(list(blank), combo))` = some_f(c(list(blank), combo)) ,
`some_ge("a", c(blank, NA, letters))` = some_ge("a", c(blank, NA, letters)) ,
`some_gt("a", c(blank, NA, letters))` = some_gt("a", c(blank, NA, letters)) ,
`some_in(NULL, blank, combo)` = some_in(NULL, blank, combo) ,
`some_le("a", c(blank, NA, letters))` = some_le("a", c(blank, NA, letters)) ,
`some_lt("a", c(blank, NA, letters))` = some_lt("a", c(blank, NA, letters)) ,
`some_mf(NULL, blank, combo)` = some_mf(NULL, blank, combo) ,
`some_nav(c(blank, NA, letters))` = some_nav(c(blank, NA, letters)) ,
`some_nav(chr.mat)` = some_nav(chr.mat) ,
`some_okv(c(blank, NA, letters))` = some_okv(c(blank, NA, letters)) ,
`some_okv(chr.mat)` = some_okv(chr.mat) ,
`some_t(c(list(blank), combo))` = some_t(c(list(blank), combo)) ,
`some_tf(c(list(blank), combo))` = some_tf(c(list(blank), combo)) ,
`TRUE %.and.% 42` = TRUE %.and.% 42 ,
`TRUE %.and.% TRUE` = TRUE %.and.% TRUE ,
`TRUE %.nor.% 42` = TRUE %.nor.% 42 ,
`TRUE %.nor.% TRUE` = TRUE %.nor.% TRUE ,
`TRUE %.xor.% 42` = TRUE %.xor.% 42 ,
`TRUE %.xor.% TRUE` = TRUE %.xor.% TRUE ,
`TRUE %.or.% 42` = TRUE %.or.% 42 ,
`TRUE %.or.% TRUE` = TRUE %.or.% TRUE ,
`two_bl(c(blank, letters))` = two_bl(c(blank, letters)) ,
`two_dif("a", c(blank, NA, letters))` = two_dif("a", c(blank, NA, letters)) ,
`two_eq(NA, c(blank, NA, letters))` = two_eq(NA, c(blank, NA, letters)) ,
`two_f(c(list(blank), combo))` = two_f(c(list(blank), combo)) ,
`two_ge("a", c(blank, NA, letters))` = two_ge("a", c(blank, NA, letters)) ,
`two_gt("a", c(blank, NA, letters))` = two_gt("a", c(blank, NA, letters)) ,
`two_in(NULL, blank, combo)` = two_in(NULL, blank, combo) ,
`two_le("a", c(blank, NA, letters))` = two_le("a", c(blank, NA, letters)) ,
`two_lt("a", c(blank, NA, letters))` = two_lt("a", c(blank, NA, letters)) ,
`two_mf(NULL, blank, combo)` = two_mf(NULL, blank, combo) ,
`two_nav(c(blank, NA, letters))` = two_nav(c(blank, NA, letters)) ,
`two_nav(chr.mat)` = two_nav(chr.mat) ,
`two_okv(c(blank, NA, letters))` = two_okv(c(blank, NA, letters)) ,
`two_okv(chr.mat)` = two_okv(chr.mat) ,
`two_t(c(list(blank), combo))` = two_t(c(list(blank), combo)) ,
`two_tf(c(list(blank), combo))` = two_tf(c(list(blank), combo)) )
}
egfailsafe()
j-martineau/uj documentation built on Sept. 14, 2024, 4:40 a.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
| failsafe | R Documentation |
failsafe functions that always return a valid object.
Description
Evaluate objects, test if an object has certain properties, and conduct binary logical operations safely. these functions never stop execution; they always produce a valid result, even if that result is an error object.
Usage
failsafe(x, def = "uj.failsafe.err")
is_err(x)
not_err(x)
msg_err(x)
make_err()
fs_def(x)
fs_nll(x)
fs_scl(x, val)
fs_t(x)
fs_f(x)
fs_tf(x)
fs_na(x)
fs_ok(x)
fs_bl(x)
fs_lg(x)
fs_vec(x, val)
fs_null(x)
scl_bl(x)
scl_t(x)
scl_f(x)
scl_tf(x)
scl_lg(x)
scl_na(x)
vec_bl(x)
vec_t(x)
vec_f(x)
vec_tf(x)
vec_na(x)
fs_or(x, or = NULL)
or_f(x)
or_t(x)
or_bl(x)
or_c0(x)
or_i0(x)
or_l0(x)
or_n0(x)
or_na(x)
or_nac(x)
or_nai(x)
or_nal(x)
or_nar(x)
or_null(x)
is_id(x, y)
not_id(x, y)
is_IN(x, ...)
is_MF(x, ...)
HAS(x, y)
LACKS(x, y)
is_EQ(x, y)
is_GE(x, y)
is_GT(x, y)
is_LE(x, y)
is_LT(x, y)
is_DIF(x, y)
is_F(x)
is_T(x)
is_BL(x)
is_TF(x)
is_NAV(x)
is_OKV(x)
is_LG(x)
is_in(x, ...)
is_mf(x, ...)
has(x, y)
not(x)
lacks(x, y)
is_eq(x, y)
is_ge(x, y)
is_gt(x, y)
is_le(x, y)
is_lt(x, y)
is_dif(x, y)
is_f(x)
is_t(x)
is_bl(x)
is_tf(x)
is_nav(x)
is_okv(x)
is_seq(x, y)
is_veq(x, y)
is_sdif(x, y)
is_vdif(x, y)
OR(x, y)
AND(x, y)
XOR(x, y)
NOR(x, y)
or(x, y)
and(x, y)
one(x, y)
nor(x, y)
not_IN(x, ...)
not_MF(x, ...)
not_HAS(x, y)
not_LACKS(x, y)
not_EQ(x, y)
not_GE(x, y)
not_GT(x, y)
not_LE(x, y)
not_LT(x, y)
not_DIF(x, y)
not_F(x)
not_T(x)
not_TF(x)
not_BL(x)
not_NAV(x)
not_OKV(x)
not_LG(x)
not_in(x, ...)
not_mf(x, ...)
not_has(x, y)
not_lacks(x, y)
not_eq(x, y)
not_ge(x, y)
not_gt(x, y)
not_le(x, y)
not_lt(x, y)
not_dif(x, y)
not_f(x)
not_t(x)
not_tf(x)
not_bl(x)
not_nav(x)
not_okv(x)
not_seq(x, y)
not_veq(x, y)
not_sdif(x, y)
not_vdif(x, y)
n_in(x, ...)
n_mf(x, ...)
n_has(x, y)
n_lacks(x, y)
n_eq(x, y)
n_ge(x, y)
n_gt(x, y)
n_le(x, y)
n_lt(x, y)
n_dif(x, y)
n_f(x)
n_t(x)
n_tf(x)
n_bl(x)
n_nav(x)
n_okv(x)
none_f(x)
none_t(x)
none_tf(x)
none_bl(x)
none_eq(x, y)
none_ge(x, y)
none_gt(x, y)
none_le(x, y)
none_lt(x, y)
none_in(x, ...)
none_mf(x, ...)
none_dif(x, y)
none_nav(x)
none_okv(x)
has_none(x, y)
lacks_none(x, y)
any_f(x)
any_t(x)
any_bl(x)
any_eq(x, y)
any_ge(x, y)
any_gt(x, y)
any_in(x, ...)
any_le(x, y)
any_lt(x, y)
any_mf(x, ...)
any_tf(x)
any_dif(x, y)
any_nav(x)
any_okv(x)
has_any(x, y)
lacks_any(x, y)
one_f(x)
one_t(x)
one_bl(x)
one_eq(x, y)
one_ge(x, y)
one_gt(x, y)
one_in(x, ...)
one_le(x, y)
one_lt(x, y)
one_mf(x, ...)
one_tf(x)
one_dif(x, y)
one_nav(x)
one_okv(x)
has_one(x, y)
lacks_one(x, y)
all_f(x)
all_t(x)
all_bl(x)
all_eq(x, y)
all_ge(x, y)
all_gt(x, y)
all_in(x, ...)
all_le(x, y)
all_lt(x, y)
all_mf(x, ...)
all_tf(x)
all_dif(x, y)
all_nav(x)
all_okv(x)
has_all(x, y)
lacks_all(x, y)
some_f(x)
some_t(x)
some_bl(x)
some_eq(x, y)
some_le(x, y)
some_ge(x, y)
some_gt(x, y)
some_in(x, ...)
some_lt(x, y)
some_mf(x, ...)
some_tf(x)
some_dif(x, y)
some_nav(x)
some_okv(x)
has_some(x, y)
lacks_some(x, y)
two_f(x)
two_t(x)
two_bl(x)
two_eq(x, y)
two_ge(x, y)
two_gt(x, y)
two_in(x, ...)
two_le(x, y)
two_lt(x, y)
two_mf(x, ...)
two_tf(x)
two_dif(x, y)
two_nav(x)
two_okv(x)
has_two(x, y)
lacks_two(x, y)
many_f(x)
many_t(x)
many_bl(x)
many_eq(x, y)
many_ge(x, y)
many_gt(x, y)
many_in(x, ...)
many_le(x, y)
many_lt(x, y)
many_mf(x, ...)
many_tf(x)
many_dif(x, y)
many_nav(x)
many_okv(x)
has_many(x, y)
lacks_many(x, y)
x %.IN.% y
x %.MF.% y
x %.EQ.% y
x %.GE.% y
x %.GT.% y
x %.LE.% y
x %.LT.% y
x %.HAS.% y
x %.DIF.% y
x %.LACKS.% y
x %.in.% y
x %.mf.% y
x %.eq.% y
x %.ge.% y
x %.gt.% y
x %.le.% y
x %.lt.% y
x %.has.% y
x %.dif.% y
x %.lacks.% y
x %.seq.% y
x %.veq.% y
x %.neq.% y
x %.sdif.% y
x %.vdif.% y
x %.ndif.% y
x %.OR.% y
x %.AND.% y
x %.XOR.% y
x %.NOR.% y
x %.or.% y
x %.and.% y
x %.xor.% y
x %.nor.% y
Arguments
def |
A character scalar default error message if forcing evaluation produces an error. If not a character scalar, it is replaced with the default. |
val, or, x, y |
Any object/expression to be evaluated, whether or not doing so produces an error. |
... |
Any objects/expressions to be evaluated, whether or not doing so produces an error. |
Details
Error management functions
These functions evaluate generate, check for, and manage error objects.
make_err | generate object of class 'simpleError'. |
msg_err | get error message, if any; otherwise, NULL. |
not_err | Does evaluating x not produce an error?. |
is_err | Does evaluating x produce an error? |
failsafe check for classes of objects with values
failsafe | Returns x if identity evaluation does not_ cause an error. Returns
an error object otherwise with the attribute stack = uj::callers(). |
fs_null | x is NULL. |
fs_def | x is defined (not NULL). |
fs_scl | x is scalar of a specific atomic value. |
fs_t | x is scalar TRUE. |
fs_f | x is scalar FALSE. |
fs_na | x is scalar NA. |
fs_tf | x is scalar TRUE or scalar FALSE. |
scl_f | x is scalar FALSE |
scl_t | x is scalar TRUE |
scl_tf | x is scalar TRUE or FALSE. |
scl_lg | x is scalar TRUE, FALSE, or NA. |
scl_bl | x is blank string scalar (""). |
scl_na | x is scalar NA |
fs_vec | Elements of x are of a specific atomic value. |
vec_f | Elements of x are FALSE. |
vec_t | Elements of x are TRUE. |
vec_tf | Elements of x are TRUE or FALSE. |
vec_lg | Elements of x are TRUE, FALSE, or NA. |
vec_bl | Elements of x are blank strings. |
vec_na | Elements of x are NA. |
Forced-evaluation functions with conditional return values
These functions force evaluation of x returning values as shown in the following table with the first value returned when forcing evaluation does not produce an error and the second when it does:
fs_or | x or something else if evaluating x produces an error |
or_f | x or FALSE |
or_t | x or TRUE |
or_c0 | x or character(0) |
or_i0 | x or integer(0) |
or_l0 | x or logical(0) |
or_n0 | x or numeric(0) |
or_bl | x or "" |
or_na | x or NA |
or_nac | x or NA_character_ |
or_nai | x or NA_integer_ |
or_nal | x or NA (logical) |
or_nar | x or NA_real_ |
Binary comparison functions
These are binary functions that always produce either scalar TRUE or scalar FALSE. They return TRUE when two variables meet the conditions shown in the following table and FALSE in every other circumstance (where fx and fy)
%.is.% | failsafe(identical(x, y)) |
%.isnt.% | !(x %.is.% y) |
%.in.% | sapply(failsafe(x %in% y), isTRUE) |
%.in.% | if x is atomic scalar, x %.in.% y, otherwise FALSE |
%.mf.% | !(x %.in.% y) (missing from) |
%.has.% | y %.in.% x (x has each y value) |
%.lacks.% | y %.mf.% x (x lacks each y value) |
%.eq.% | If x and y match^{(1)}, x = y, otherwise FALSE |
%.ge.% | If x and y match^{(1)}, x ≥ y, otherwise FALSE |
%.gt.% | If x and y match^{(1)}, x > y, otherwise FALSE |
%.le.% | If x and y match^{(1)}, x ≤ y, otherwise FALSE |
%.lt.% | If x and y match^{(1)}, x < y, otherwise FALSE |
%.dif.% | If x and y match^{(1)}, x ≠ y, otherwise TRUE |
%.seq.% | x and y are setequal^{(4)} |
%.veq.% | x and y are vector equal^{(5)} |
%.sdif.% | x and y are set different^{(6)} |
%.vdif.% | x and y are vector different^{(7)} |
%.or.% | values of x and/or y are TRUE |
%.and.% | values of x and y are TRUE |
%.xor.% | values of either x or y are TRUE |
%.nor.% | values of neither x nor y are TRUE |
%.mf.% | x is atomic scalar and x %.mf.% y |
%.has.% | y is atomic scalar and x %.has.% y |
%.lacks.% | y is atomic scalar and x %.lacks.% y |
%.eq.% | x and y are atomic scalar and x = y ^{(2)} |
%.ge.% | x and y are atomic scalar and x ≥ y ^{(2)} |
%.gt.% | x and y are atomic scalar and x > y ^{(2)} |
%.le.% | x and y are atomic scalar and x ≤ y ^{(2)} |
%.lt.% | x and y are atomic scalar and x ≥ y ^{(2)} |
%.dIF.% | x and y are not atomic scalar equal ^{(3)} |
%.OR.% | x and/or y are scalar TRUE |
%.AND.% | x and y are scalar TRUE |
%.XOR.% | either x or y is scalar TRUE |
%.NOR.% | neither x nor y is scalar TRUE |
^{(1)} Of equal length and compatible modes. |
^{(2)} Of compatible modes and meeting the (in)equality. |
^{(3)} not meeting the requirements of %.eq0.%. |
^{(4)} atomic, of the same length, with the same values in the same order. |
^{(5)} atomic, possibly of different lengths, and containing the same unique values regardless of order or duplicates. |
^{(6)} not meeting the requirements of %.seq.%. |
^{(7)} not meeting the requirements of %.veq.%. |
Scalar value, membership, and equality/inequality checking functions
These functions check for class, mode, and/or value and/or count the number of checks passed. they always produce TRUE, FALSE, or an integer scalar.
Function names are constructed of root words, prefixes, and/or suffixes. Root word specify the type of check conducted. Prefixes and suffixes specify how to modify the results of a check or how to apply the check to each ... argument and check whether a certain number of ... args passed the checks.
Uppercase root words indicate one or both arguments must be scalar. Lowercase root words indicate arguments may be vectors.
Root words for atomic scalar value checking functions
nav | x is atomic and values are NA. |
okv | x is atomic and values are not NA. |
bl | x is atomic and values are blanks (""). |
lg | x is atomic and values are logical (TRUE, FALSE, or NA). |
tf | x is atomic and values are TRUE or FALSE. |
f | x is atomic and values are TRUE. |
t | x is atomic and valules are FALSE. |
Root words for atomic value membership checking functions
lacks | x lacks values of y. |
has | x has values of y. |
in | x in values of y. |
mf | x missing from values of y. |
Root words for equality/inequality checking functions
id | objects are identical |
ge | x is greater than or equal to y. |
gt | x is greater than y. |
le | x is less than or equal to y. |
lt | x is less than y. |
eq | values are equal |
dif | values are different |
seq | values are set equal |
sdif | values are set different |
veq | values are vector equal |
vdif | values are vector different |
Modifier prefixes/suffixes
n | count ... args passing the check. |
is | Keep the result of a check as is. |
not | Negate the result of a check. |
Apply-and-sweep prefixes/suffixes evaluating whether a certain number of checks were passed
the following table contains prefixes in the first column, and in the second, the number of checks that must be passed to return TRUE.
none | 0 values passed the check. |
any | > 0 values passed the check. |
one | 1 value passed the check. |
some | > 1 values passed the check. |
two | 2 values passed the check. |
many | > 2 values passed the check. |
all | all values passed the check. |
Identity-equality, set-equality and vector-equality checking functions
| is | not | |
| id | is_id | not_id |
| seq | is_seq | not_deq |
| veq | is_veq | not_veq |
| sdif | is_sdif | not_sdif |
| vdif | is_vdif | not_vdif |
atomic scalar value checking functions
| is | not | |
| t | is_T | not_T |
| f | is_F | not_F |
| tf | is_TF | not_TF |
| lg | is_LG | not_LG |
| bl | is_BL | not_BL |
| eq | is_EQ | not_EQ |
| ge | is_GE | not_GE |
| gt | is_GT | not_GT |
| le | is_LE | not_LE |
| lt | is_LT | not_LT |
| nav | is_NAV | not_NAV |
| okv | is_OKV | not_OKV |
| dif | is_DIF | not_DIF |
atomic scalar value membership checking functions
| is | not | |
| in | is_IN | not_IN |
| mf | is_MF | not_MF |
| has | HAS | not_HAS |
| lacks | LACKS | not_LACKS |
atomic value checking functions
| is | n | not | none | one | two | any | some | many | all_ | |
| t | is_t | n_t | not_t | none_t | one_t | two_t | any_t | some_t | many_t | all_t |
| f | is_f | n_f | not_f | none_f | one_f | two_f | any_f | some_f | many_f | all_f |
| tf | is_tf | n_tf | not_tf | none_tf | one_tf | two_tf | any_tf | some_tf | many_tf | all_tf |
| bl | is_bl | n_bl | not_bl | none_bl | one_bl | two_bl | any_bl | some_bl | many_bl | all_bl |
| eq | is_eq | n_eq | not_eq | none_eq | one_eq | two_eq | any_eq | some_eq | many_eq | all_eq |
| ge | is_ge | n_ge | not_ge | none_ge | one_ge | two_ge | any_ge | some_ge | many_ge | all_ge |
| gt | is_gt | n_gt | not_gt | none_gt | one_gt | two_gt | any_gt | some_gt | many_gt | all_gt |
| le | is_le | n_le | not_le | none_le | one_le | two_le | any_le | some_le | many_le | all_le |
| lt | is_lt | n_lt | not_lt | none_lt | one_lt | two_lt | any_lt | some_lt | many_lt | all_lt |
| dif | is_dif | n_dif | not_dif | none_dif | one_dif | two_dif | any_dif | some_dif | many_dif | all_dif |
| nav | is_nav | n_nav | not_nav | none_nav | one_nav | two_nav | any_nav | some_nav | many_nav | all_nav |
| okv | is_okv | n_okv | not_okv | none_okv | one_okv | two_okv | any_okv | some_okv | many_okv | all_okv |
atomic value membership checking functions
| is | n | not | none | one | two | any | some | many | all | |
| in | is_in | n_in | not_in | in_none | in_one | in_two | in_any | in_some | in_many | in_all |
| mf | is_mf | n_mf | not_mf | mf_none | mf_one | mf_two | mf_any | mf_some | mf_many | mf_all |
| has | has | n_has | not_has | has_none | has_one | has_two | has_any | has_some | has_many | has_all |
| lacks | locks | n_lacks | not_lacks | lacks_none | lacks_one | lacks_two | lacks_any | lacks_some | lacks_many | lacks_all |
Value
A logical scalar or vector.
Examples
egfailsafe <- function() {
abc <- c("a", "b", "c")
abc <- abc
blank <- ""
mss.scl <- Na
lgl.scl <- FALSE
fac.scl <- factor("q", levels = c("x", "q"))
fac.vec <- factor(c("x", "q"), levels = c("x", "q"))
chr.mat <- matrix(c("a", "b", "c", "Na"), nrow = 2)
chr.dtf <- data.frame(abc = letters[1:3], def = letters[4:6])
num.vls <- list(first3 = c(1:3, NA), next3 = c(4:6, NA))
combo <- list(mss.scl, lgl.scl, fac.vec, chr.mat, chr.dtf, numvls)
attr(abc, "custom") <- "custom"
list(`"a" %.AND.% FALSE` = "a" %.AND.% FALSE ,
`"a" %.in.% abc` = "a" %.in.% abc ,
`"a" %.NOR.% FALSE` = "a" %.OR.% FALSE ,
`"a" %.XOR.% FALSE` = "a" %.XOR.% FALSE ,
`"a" %.OR.% FALSE` = "a" %.OR.% FALSE ,
`"a" %.mf.% abc` = "a" %.mf.% abc ,
`"a" %.and.% FALSE` = "a" %.and.% FALSE ,
`"a" %.in.% abc` = "a" %.in.% abc ,
`"a" %.nor.% FALSE` = "a" %.or.% FALSE ,
`"a" %.xor.% FALSE` = "a" %.xor.% FALSE ,
`"a" %.or.% FALSE` = "a" %.or.% FALSE ,
`"a" %.mf.% abc` = "a" %.mf.% abc ,
`1 %.in.% abc` = 1 %.in.% abc ,
`1 %.mf.% abc` = 1 %.mf.% abc ,
`abc %.EQ.% abc` = abc %.EQ.% abc ,
`abc %.eq.% letters[1:3]` = abc %.eq.% letters[1:3] ,
`abc %.eq.% NULL` = abc %.eq.% NULL ,
`abc %.HAS.% "a"` = abc %.HAS.% "a" ,
`abc %.HAS.% 1` = abc %.HAS.% 1 ,
`abc %.HAS.% NULL` = abc %.HAS.% NULL ,
`abc %.has.% letters[1:6]` = abc %.has.% "a" ,
`abc %.has.% 1:3` = abc %.has.% 1 ,
`abc %.has.% NULL` = abc %.has.% NULL ,
`abc %.is.% NULL` = abc %.is.% NULL ,
`abc %.lacks.% "a"` = abc %.lacks.% "a" ,
`abc %.lacks.% 1` = abc %.lacks.% 1 ,
`abc %.lacks.% NULL` = abc %.lacks.% NULL ,
`abc %.is.% abc` = abc %.is.% abc ,
`abc %.is.% letters[1:3]` = abc %.is.% letters[1:3] ,
`abc %.isnt.% abc` = abc %.isnt.% abc ,
`abc %.isnt.% letters[4:6]` = abc %.isnt.% letters[4:6] ,
`all_bl(c(blank, letters))` = all_bl(c(blank, letters)) ,
`all_dif("a", c(blank, NA, letters))` = all_dif("a", c(blank, NA, letters)) ,
`all_eq(NA, c(blank, NA, letters))` = all_eq(NA, c(blank, NA, letters)) ,
`all_f(c(list(blank), combo))` = all_f(c(list(blank), combo)) ,
`all_ge("a", c(blank, NA, letters))` = all_ge("a", c(blank, NA, letters)) ,
`all_gt("a", c(blank, NA, letters))` = all_gt("a", c(blank, NA, letters)) ,
`all_in(NULL, blank, combo)` = all_in(NULL, blank, combo) ,
`all_le("a", c(blank, NA, letters))` = all_le("a", c(blank, NA, letters)) ,
`all_lg(c(NA, TRUE, FALSE))` = all_lg(c(NA, TRUE, FALSE)) ,
`all_lt("a", c(blank, NA, letters))` = all_lt("a", c(blank, NA, letters)) ,
`all_mf(NULL, blank, combo)` = all_mf(NULL, blank, combo) ,
`all_nav(c(blank, NA, letters))` = all_nav(c(blank, NA, letters)) ,
`all_nav(chr.mat)` = all_nav(chr.mat) ,
`all_okv(c(blank, NA, letters))` = all_okv(c(blank, NA, letters)) ,
`all_okv(chr.mat)` = all_okv(chr.mat) ,
`all_t(c(list(blank), combo))` = all_t(c(list(blank), combo)) ,
`all_tf(c(list(blank), combo))` = all_tf(c(list(blank), combo)) ,
`any_bl(c(blank, letters))` = any_bl(c(blank, letters)) ,
`any_dif("a", c(blank, NA, letters))` = any_dif("a", c(blank, NA, letters)) ,
`any_eq(NA, c(blank, NA, letters))` = any_eq(NA, c(blank, NA, letters)) ,
`any_f(c(list(blank), combo))` = any_f(c(list(blank), combo)) ,
`any_ge("a", c(blank, NA, letters))` = any_ge("a", c(blank, NA, letters)) ,
`any_gt("a", c(blank, NA, letters))` = any_gt("a", c(blank, NA, letters)) ,
`any_in(NULL, blank, combo)` = any_in(NULL, blank, combo) ,
`any_le("a", c(blank, NA, letters))` = any_le("a", c(blank, NA, letters)) ,
`any_lg(c(NA, TRUE, FALSE))` = any_lg(c(NA, TRUE, FALSE)) ,
`any_lt("a", c(blank, NA, letters))` = any_lt("a", c(blank, NA, letters)) ,
`any_mf(NULL, blank, combo)` = any_mf(NULL, blank, combo) ,
`any_nav(c(blank, NA, letters))` = any_nav(c(blank, NA, letters)) ,
`any_nav(chr.mat)` = any_nav(chr.mat) ,
`any_okv(c(blank, NA, letters))` = any_okv(c(blank, NA, letters)) ,
`any_okv(chr.mat)` = any_okv(chr.mat) ,
`any_t(c(list(blank), combo))` = any_t(c(list(blank), combo)) ,
`any_tf(c(list(blank), combo))` = any_tf(c(list(blank), combo)) ,
`failsafe(non.existent.variable)` = failsafe(non.existent.variable) ,
`failsafe(pi)` = failsafe(pi) ,
`FALSE %.and.% FALSE` = FALSE %.and.% FALSE ,
`FALSE %.nor.% FALSE` = FALSE %.nor.% FALSE ,
`FALSE %.xor.% FALSE` = FALSE %.xor.% FALSE ,
`FALSE %.or.% FALSE` = FALSE %.or.% FALSE ,
`has_all(blank, combo)` = has_all(blank, combo) ,
`has_any(blank, combo)` = has_any(blank, combo) ,
`has_many(blank, combo)` = has_many(blank, combo) ,
`has_none(blank, combo)` = has_none(blank, combo) ,
`has_one(blank, combo)` = has_one(blank, combo) ,
`has_some(blank, combo)` = has_some(blank, combo) ,
`has_two(blank, combo)` = has_two(blank, combo) ,
`is_bl("")` = is_bl("") ,
`is_bl("a")` = is_bl("a") ,
`is_bl(c("", ""))` = is_bl(c("", "")) ,
`is_bl(NA)` = is_bl(NA) ,
`is_BL("")` = is_BL("") ,
`is_BL("a")` = is_BL("a") ,
`is_BL(c("", ""))` = is_BL(c("", "")) ,
`is_BL(NA)` = is_BL(NA) ,
`is_dif("", "")` = is_dif("", "") ,
`is_dif("word", 7)` = is_dif("word", 7) ,
`is_dif(chr.mat, chr.mat)` = is_dif(chr.mat, chr.mat) ,
`is_dif(NA, NA)` = is_dif(NA, NA) ,
`is_DIF("", "")` = is_DIF("", "") ,
`is_DIF("word", 7)` = is_DIF("word", 7) ,
`is_DIF(chr.mat, chr.mat)` = is_DIF(chr.mat, chr.mat) ,
`is_DIF(NA, NA)` = is_DIF(NA, NA) ,
`is_eq("", "")` = is_eq("", "") ,
`is_eq("word", 7)` = is_eq("word", 7) ,
`is_eq(chr.mat, chr.mat)` = is_eq(chr.mat, chr.mat) ,
`is_eq(NA, NA)` = is_eq(NA, NA) ,
`is_EQ("", "")` = is_EQ("", "") ,
`is_EQ("word", 7)` = is_EQ("word", 7) ,
`is_EQ(chr.mat, chr.mat)` = is_EQ(chr.mat, chr.mat) ,
`is_EQ(NA, NA)` = is_EQ(NA, NA) ,
`is_err(non.existent.variable)` = is_err(non.existent.variable) ,
`is_err(pi)` = is_err(pi) ,
`is_f(c(TRUE, FALSE))` = is_f(c(TRUE, FALSE)) ,
`is_f(chr.mat)` = is_f(chr.mat) ,
`is_f(NA)` = is_f(NA) ,
`is_f(TRUE)` = is_f(TRUE) ,
`is_f(TRUE)` = is_f(TRUE) ,
`is_F(c(TRUE, FALSE))` = is_F(c(TRUE, FALSE)) ,
`is_F(chr.mat)` = is_F(chr.mat) ,
`is_F(FALSE)` = is_F(FALSE) ,
`is_F(NA)` = is_F(NA) ,
`is_F(TRUE)` = is_F(TRUE) ,
`is_ge("a", "b")` = is_ge("a", "b") ,
`is_ge("b", "a")` = is_ge("b", "a") ,
`is_ge(1, 1)` = is_ge(1, 1) ,
`is_ge(chr.mat, chr.mat)` = is_ge(chr.mat, chr.mat) ,
`is_GE("a", "b")` = is_GE("a", "b") ,
`is_GE("b", "a")` = is_GE("b", "a") ,
`is_GE(1, 1)` = is_GE(1, 1) ,
`is_GE(chr.mat, chr.mat)` = is_GE(chr.mat, chr.mat) ,
`is_gt("a", "b")` = is_gt("a", "b") ,
`is_gt("b", "a")` = is_gt("b", "a") ,
`is_gt(1, 1)` = is_gt(1, 1) ,
`is_gt(chr.mat, chr.mat)` = is_gt(chr.mat, chr.mat) ,
`is_GT("a", "b")` = is_GT("a", "b") ,
`is_GT("b", "a")` = is_GT("b", "a") ,
`is_GT(1, 1)` = is_GT(1, 1) ,
`is_GT(chr.mat, chr.mat)` = is_GT(chr.mat, chr.mat) ,
`is_in(1, "", "a", 1:2)` = is_in(1, "", "a", 1:2) ,
`is_in(1, "a", letters)` = is_in(1, "a", letters) ,
`is_in(NULL, blank, combo)` = is_in(NULL, blank, combo) ,
`is_IN(1, "", "a", 1:2)` = is_IN(1, "", "a", 1:2) ,
`is_IN(1, "a", letters)` = is_IN(1, "a", letters) ,
`is_IN(NULL, blank, combo)` = is_IN(NULL, blank, combo) ,
`is_BL(chr.mat)` = is_BL(chr.mat) ,
`is_le("a", "b")` = is_le("a", "b") ,
`is_le("b", "a")` = is_le("b", "a") ,
`is_le(1, 1)` = is_le(1, 1) ,
`is_le(chr.mat, chr.mat)` = is_le(chr.mat, chr.mat) ,
`is_LE("a", "b")` = is_LE("a", "b") ,
`is_LE("b", "a")` = is_LE("b", "a") ,
`is_LE(1, 1)` = is_LE(1, 1) ,
`is_LE(chr.mat, chr.mat)` = is_LE(chr.mat, chr.mat) ,
`is_LG(c(TRUE, FALSE))` = is_LG(c(TRUE, FALSE)) ,
`is_LG(chr.mat)` = is_LG(chr.mat) ,
`is_LG(FALSE)` = is_LG(FALSE) ,
`is_LG(NA)` = is_LG(NA) ,
`is_LG(TRUE)` = is_LG(TRUE) ,
`is_lt("a", "b")` = is_lt("a", "b") ,
`is_lt("b", "a")` = is_lt("b", "a") ,
`is_lt(1, 1)` = is_lt(1, 1) ,
`is_lt(chr.mat, chr.mat)` = is_lt(chr.mat, chr.mat) ,
`is_LT("a", "b")` = is_LT("a", "b") ,
`is_LT("b", "a")` = is_LT("b", "a") ,
`is_LT(1, 1)` = is_LT(1, 1) ,
`is_LT(chr.mat, chr.mat)` = is_LT(chr.mat, chr.mat) ,
`is_mf(1, "", "a", 1:2)` = is_mf(1, "", "a", 1:2) ,
`is_mf(1, "a", letters)` = is_mf(1, "a", letters) ,
`is_mf(NULL, blank, combo)` = is_mf(NULL, blank, combo) ,
`is_MF(1, "", "a", 1:2)` = is_MF(1, "", "a", 1:2) ,
`is_MF(1, "a", letters)` = is_MF(1, "a", letters) ,
`is_MF(NULL, blank, combo)` = is_MF(NULL, blank, combo) ,
`is_nav(1)` = is_nav(1) ,
`is_nav(c(NA, NA))` = is_nav(c(NA, NA)) ,
`is_nav(chr.mat)` = is_nav(chr.mat) ,
`is_nav(NA)` = is_nav(NA) ,
`is_NAV(1)` = is_NAV(1) ,
`is_NAV(c(NA, NA))` = is_NAV(c(NA, NA)) ,
`is_NAV(chr.mat)` = is_NAV(chr.mat) ,
`is_NAV(NA)` = is_NAV(NA) ,
`is_okv(1)` = is_okv(1) ,
`is_okv(c(NA, NA))` = is_okv(c(NA, NA)) ,
`is_okv(chr.mat)` = is_ok(chr.mat) ,
`is_okv(NA)` = is_okv(NA) ,
`is_OKV(1)` = is_OKV(1) ,
`is_OKV(c(NA, NA))` = is_OKV(c(NA, NA)) ,
`is_OKV(chr.mat)` = is_OKV(chr.mat) ,
`is_OKV(NA)` = is_OKV(NA) ,
`is_seq(1, letters)` = is_seq(1, letters) ,
`is_seq(1, letters)` = is_seq(1, letters) ,
`is_seq(1:3, c(1, 2, 3, 2, 1))` = is_seq(1:3, c(1, 2, 3, 2, 1)) ,
`is_seq(1:3, c(1, 2, 3, 2, 1))` = is_seq(1:3, c(1, 2, 3, 2, 1)) ,
`is_seq(1:3, c(1, 2, 3))` = is_seq(1:3, c(1, 2, 3)) ,
`is_seq(1:3, c(1, 2, 3))` = is_seq(1:3, c(1, 2, 3)) ,
`is_t(c(TRUE, FALSE))` = is_t(c(TRUE, FALSE)) ,
`is_t(chr.mat)` = is_t(chr.mat) ,
`is_t(NA)` = is_t(NA) ,
`is_t(TRUE)` = is_t(TRUE) ,
`is_t(TRUE)` = is_t(TRUE) ,
`is_T(c(TRUE, FALSE))` = is_T(c(TRUE, FALSE)) ,
`is_T(chr.mat)` = is_T(chr.mat) ,
`is_T(FALSE)` = is_T(FALSE) ,
`is_T(NA)` = is_T(NA) ,
`is_T(TRUE)` = is_T(TRUE) ,
`is_tf(c(TRUE, FALSE))` = is_tf(c(TRUE, FALSE)) ,
`is_tf(chr.mat)` = is_tf(chr.mat) ,
`is_tf(chr.mat)` = is_tf(chr.mat) ,
`is_tf(NA)` = is_tf(NA) ,
`is_tf(TRUE)` = is_tf(TRUE) ,
`is_tf(TRUE)` = is_tf(TRUE) ,
`is_TF(c(TRUE, FALSE))` = is_TF(c(TRUE, FALSE)) ,
`is_TF(chr.mat)` = is_TF(chr.mat) ,
`is_TF(FALSE)` = is_TF(FALSE) ,
`is_TF(NA)` = is_TF(NA) ,
`is_TF(TRUE)` = is_TF(TRUE) ,
`is_veq(1, letters)` = is_veq(1, letters) ,
`is_veq(1:3, c(1, 2, 3, 2, 1))` = is_veq(1:3, c(1, 2, 3, 2, 1)) ,
`is_veq(1:3, c(1, 2, 3, 2, 1))` = is_veq(1:3, c(1, 2, 3, 2, 1)) ,
`is_veq(1:3, letters)` = is_veq(1:3, letters) ,
`is_veq(1:3, c(1, 2, 3))` = is_veq(1:3, c(1, 2, 3)) ,
`is_veq(1:3, c(1, 2, 3))` = is_veq(1:3, c(1, 2, 3)) ,
`lacks_all(blank, combo)` = lacks_all(blank, combo) ,
`lacks_any(blank, combo)` = lacks_any(blank, combo) ,
`lacks_many(blank, combo)` = lacks_many(blank, combo) ,
`lacks_none(blank, combo)` = lacks_none(blank, combo) ,
`lacks_one(blank, combo)` = lacks_one(blank, combo) ,
`lacks_some(blank, combo)` = lacks_some(blank, combo) ,
`lacks_two(blank, combo)` = lacks_two(blank, combo) ,
`many_bl(c(blank, letters))` = many_bl(c(blank, letters)) ,
`many_dif("a", c(blank, NA, letters))` = many_dif("a", c(blank, NA, letters)),
`many_eq(NA, c(blank, NA, letters))` = many_eq(NA, c(blank, NA, letters)) ,
`many_f(c(list(blank), combo))` = many_f(c(list(blank), combo)) ,
`many_ge("a", c(blank, NA, letters))` = many_ge("a", c(blank, NA, letters)) ,
`many_gt("a", c(blank, NA, letters))` = many_gt("a", c(blank, NA, letters)) ,
`many_in(NULL, blank, combo)` = many_in(NULL, blank, combo) ,
`many_le("a", c(blank, NA, letters))` = many_le("a", c(blank, NA, letters)) ,
`many_lg(c(NA, TRUE, FALSE))` = many_lg(c(NA, TRUE, FALSE)) ,
`many_lt("a", c(blank, NA, letters))` = many_lt("a", c(blank, NA, letters)) ,
`many_mf(NULL, blank, combo)` = many_mf(NULL, blank, combo) ,
`many_nav(c(blank, NA, letters))` = many_nav(c(blank, NA, letters)) ,
`many_nav(chr.mat)` = many_nav(chr.mat) ,
`many_okv(c(blank, NA, letters))` = many_okv(c(blank, NA, letters)) ,
`many_okv(chr.mat)` = many_okv(chr.mat) ,
`many_t(c(list(blank), combo))` = many_t(c(list(blank), combo)) ,
`many_tf(c(list(blank), combo))` = many_tf(c(list(blank), combo)) ,
`msg_err(non.existent.variable)` = msg_err(non.existent.variable) ,
`msg_err(pi)` = msg_err(pi) ,
`n_bl(c(list(blank), combo))` = n_bl(c(list(blank), combo)) ,
`n_f(c(list(blank), combo))` = n_f(c(list(blank), combo)) ,
`n_has(blank, combo)` = n_has(blank, combo) ,
`n_in(NULL, blank, combo)` = n_in(NULL, blank, combo) ,
`n_lacks(blank, combo)` = n_lacks(blank, combo) ,
`n_mf(NULL, blank, combo)` = n_mf(NULL, blank, combo) ,
`n_nav(chr.mat)` = n_nav(chr.mat) ,
`n_okv(chr.mat)` = n_okv(chr.mat) ,
`none_bl(c(blank, letters))` = none_bl(c(blank, letters)) ,
`none_dif("a", c(blank, NA, letters))` = none_dif("a", c(blank, NA, letters)),
`none_eq(NA, c(blank, NA, letters))` = none_eq(NA, c(blank, NA, letters)) ,
`none_f(c(list(blank), combo))` = none_f(c(list(blank), combo)) ,
`none_ge("a", c(blank, NA, letters))` = none_ge("a", c(blank, NA, letters)) ,
`none_gt("a", c(blank, NA, letters))` = none_gt("a", c(blank, NA, letters)) ,
`none_in(NULL, blank, combo)` = none_in(NULL, blank, combo) ,
`none_le("a", c(blank, NA, letters))` = none_le("a", c(blank, NA, letters)) ,
`none_lg(c(NA, TRUE, FALSE))` = none_lg(c(NA, TRUE, FALSE)) ,
`none_lt("a", c(blank, NA, letters))` = none_lt("a", c(blank, NA, letters)) ,
`none_mf(NULL, blank, combo)` = none_mf(NULL, blank, combo) ,
`none_nav(c(blank, NA, letters))` = none_nav(c(blank, NA, letters)) ,
`none_nav(chr.mat)` = none_nav(chr.mat) ,
`none_okv(c(blank, NA, letters))` = none_okv(c(blank, NA, letters)) ,
`none_okv(chr.mat)` = none_okv(chr.mat) ,
`none_t(c(list(blank), combo))` = none_t(c(list(blank), combo)) ,
`none_tf(c(list(blank), combo))` = none_tf(c(list(blank), combo)) ,
`not_bl("")` = not_bl("") ,
`not_bl("a")` = not_bl("a") ,
`not_bl(c("", ""))` = not_bl(c("", "")) ,
`not_bl(chr.mat)` = not_bl(chr.mat) ,
`not_bl(NA)` = not_bl(NA) ,
`not_BL("")` = not_BL("") ,
`not_BL("a")` = not_BL("a") ,
`not_BL(c("", ""))` = not_BL(c("", "")) ,
`not_BL(chr.mat)` = not_BL(chr.mat) ,
`not_BL(NA)` = not_BL(NA) ,
`not_dif("", "")` = not_dif("", "") ,
`not_dif("word", 7)` = not_dif("word", 7) ,
`not_dif(chr.mat, chr.mat)` = not_dif(chr.mat, chr.mat) ,
`not_dif(NA, NA)` = not_dif(NA, NA) ,
`not_DIF("", "")` = not_DIF("", "") ,
`not_DIF("word", 7)` = not_DIF("word", 7) ,
`not_DIF(chr.mat, chr.mat)` = not_DIF(chr.mat, chr.mat) ,
`not_DIF(NA, NA)` = not_DIF(NA, NA) ,
`not_eq("", "")` = not_eq("", "") ,
`not_eq("word", 7)` = not_eq("word", 7) ,
`not_eq(chr.mat, chr.mat)` = not_eq(chr.mat, chr.mat) ,
`not_eq(NA, NA)` = not_eq(NA, NA) ,
`not_EQ("", "")` = not_EQ("", "") ,
`not_EQ("word", 7)` = not_EQ("word", 7) ,
`not_EQ(chr.mat, chr.mat)` = not_EQ(chr.mat, chr.mat) ,
`not_EQ(NA, NA)` = not_EQ(NA, NA) ,
`not_err(non.existent.variable)` = not_err(non.existent.variable) ,
`not_err(pi)` = not_err(pi) ,
`not_f(c(TRUE, FALSE))` = not_f(c(TRUE, FALSE)) ,
`not_f(chr.mat)` = not_f(chr.mat) ,
`not_f(NA)` = not_f(NA) ,
`not_f(TRUE)` = not_f(TRUE) ,
`not_f(TRUE)` = not_f(TRUE) ,
`not_F(c(TRUE, FALSE))` = not_F(c(TRUE, FALSE)) ,
`not_F(chr.mat)` = not_F(chr.mat) ,
`not_F(FALSE)` = not_F(FALSE) ,
`not_F(NA)` = not_F(NA) ,
`not_F(TRUE)` = not_F(TRUE) ,
`not_ge("a", "b")` = not_ge("a", "b") ,
`not_ge("b", "a")` = not_ge("b", "a") ,
`not_ge(1, 1)` = not_ge(1, 1) ,
`not_ge(chr.mat, chr.mat)` = not_ge(chr.mat, chr.mat) ,
`not_GE("a", "b")` = not_GE("a", "b") ,
`not_GE("b", "a")` = not_GE("b", "a") ,
`not_GE(1, 1)` = not_GE(1, 1) ,
`not_GE(chr.mat, chr.mat)` = not_GE(chr.mat, chr.mat) ,
`not_gt("a", "b")` = not_gt("a", "b") ,
`not_gt("b", "a")` = not_gt("b", "a") ,
`not_gt(1, 1)` = not_gt(1, 1) ,
`not_gt(chr.mat, chr.mat)` = not_gt(chr.mat, chr.mat) ,
`not_GT("a", "b")` = not_GT("a", "b") ,
`not_GT("b", "a")` = not_GT("b", "a") ,
`not_GT(1, 1)` = not_GT(1, 1) ,
`not_GT(chr.mat, chr.mat)` = not_GT(chr.mat, chr.mat) ,
`not_in(1, "", "a", 1:2)` = not_in(1, "", "a", 1:2) ,
`not_in(1, "a", letters)` = not_in(1, "a", letters) ,
`not_in(NULL, blank, combo)` = not_in(NULL, blank, combo) ,
`not_IN(1, "", "a", 1:2)` = not_IN(1, "", "a", 1:2) ,
`not_IN(1, "a", letters)` = not_IN(1, "a", letters) ,
`not_IN(NULL, blank, combo)` = not_IN(NULL, blank, combo) ,
`not_le("a", "b")` = not_le("a", "b") ,
`not_le("b", "a")` = not_le("b", "a") ,
`not_le(1, 1)` = not_le(1, 1) ,
`not_le(chr.mat, chr.mat)` = not_le(chr.mat, chr.mat) ,
`not_LE("a", "b")` = not_LE("a", "b") ,
`not_LE("b", "a")` = not_LE("b", "a") ,
`not_LE(1, 1)` = not_LE(1, 1) ,
`not_LE(chr.mat, chr.mat)` = not_LE(chr.mat, chr.mat) ,
`not_LG(c(TRUE, FALSE))` = not_LG(c(TRUE, FALSE)) ,
`not_LG(chr.mat)` = not_LG(chr.mat) ,
`not_LG(FALSE)` = not_LG(FALSE) ,
`not_LG(NA)` = not_LG(NA) ,
`not_LG(TRUE)` = not_LG(TRUE) ,
`not_lt("a", "b")` = not_lt("a", "b") ,
`not_lt("b", "a")` = not_lt("b", "a") ,
`not_lt(1, 1)` = not_lt(1, 1) ,
`not_lt(chr.mat, chr.mat)` = not_lt(chr.mat, chr.mat) ,
`not_LT("a", "b")` = not_LT("a", "b") ,
`not_LT("b", "a")` = not_LT("b", "a") ,
`not_LT(1, 1)` = not_LT(1, 1) ,
`not_LT(chr.mat, chr.mat)` = not_LT(chr.mat, chr.mat) ,
`not_mf(1, "", "a", 1:2)` = not_mf(1, "", "a", 1:2) ,
`not_mf(1, "a", letters)` = not_mf(1, "a", letters) ,
`not_mf(NULL, blank, combo)` = not_mf(NULL, blank, combo) ,
`not_MF(1, "", "a", 1:2)` = not_MF(1, "", "a", 1:2) ,
`not_MF(1, "a", letters)` = not_MF(1, "a", letters) ,
`not_MF(NULL, blank, combo)` = not_MF(NULL, blank, combo) ,
`not_NAV(1)` = not_NAV(1) ,
`not_NAV(c(NA, NA))` = not_NAV(c(NA, NA)) ,
`not_NAV(chr.mat)` = not_NAV(chr.mat) ,
`not_NAV(NA)` = not_NAV(NA) ,
`not_nav(c(NA, NA), chr.mat)` = not_nav(c(NA, NA), chr.mat) ,
`not_nav(NA), not_nav(1)` = not_nav(NA), not_nav(1) ,
`not_OKV(1)` = not_OKV(1) ,
`not_OKV(c(NA, NA))` = not_OKV(c(NA, NA)) ,
`not_OKV(chr.mat)` = not_OKV(chr.mat) ,
`not_OKV(NA)` = not_OKV(NA) ,
`not_okv(c(NA, NA)` = not_okv(c(NA, NA)) ,
`not_okv(chr.mat)` = not_okv(chr.mat) ,
`not_okv(NA)` = not_okv(NA) ,
`not_okv(1)` = not_okv(1) ,
`not_seq(1, letters)` = not_seq(1, letters) ,
`not_seq(1, letters)` = not_seq(1, letters) ,
`not_seq(1:3, c(1, 2, 3, 2, 1))` = not_seq(1:3, c(1, 2, 3, 2, 1)) ,
`not_seq(1:3, c(1, 2, 3, 2, 1))` = not_seq(1:3, c(1, 2, 3, 2, 1)) ,
`not_seq(1:3, c(1, 2, 3))` = not_seq(1:3, c(1, 2, 3)) ,
`not_seq(1:3, c(1, 2, 3))` = not_seq(1:3, c(1, 2, 3)) ,
`not_t(c(TRUE, FALSE))` = not_t(c(TRUE, FALSE)) ,
`not_t(chr.mat)` = not_t(chr.mat) ,
`not_t(NA)` = not_t(NA) ,
`not_t(TRUE)` = not_t(TRUE) ,
`not_t(TRUE)` = not_t(TRUE) ,
`not_T(c(TRUE, FALSE))` = not_T(c(TRUE, FALSE)) ,
`not_T(chr.mat)` = not_T(chr.mat) ,
`not_T(FALSE)` = not_T(FALSE) ,
`not_T(NA)` = not_T(NA) ,
`not_T(TRUE)` = not_T(TRUE) ,
`not_tf(c(TRUE, FALSE))` = not_tf(c(TRUE, FALSE)) ,
`not_tf(chr.mat)` = not_tf(chr.mat) ,
`not_tf(NA)` = not_tf(NA) ,
`not_tf(TRUE)` = not_tf(TRUE) ,
`not_tf(TRUE)` = not_tf(TRUE) ,
`not_TF(c(TRUE, FALSE))` = not_TF(c(TRUE, FALSE)) ,
`not_TF(chr.mat)` = not_TF(chr.mat) ,
`not_TF(FALSE)` = not_TF(FALSE) ,
`not_TF(NA)` = not_TF(NA) ,
`not_TF(TRUE)` = not_TF(TRUE) ,
`not_veq(1, letters)` = not_veq(1, letters) ,
`not_veq(1, letters)` = not_veq(1, letters) ,
`not_veq(1:3, c(1, 2, 3, 2, 1))` = not_veq(1:3, c(1, 2, 3, 2, 1)) ,
`not_veq(1:3, c(1, 2, 3, 2, 1))` = not_veq(1:3, c(1, 2, 3, 2, 1)) ,
`not_veq(1:3, c(1, 2, 3))` = not_veq(1:3, c(1, 2, 3)) ,
`not_veq(1:3, c(1, 2, 3))` = not_veq(1:3, c(1, 2, 3)) ,
`n_t(c(list(blank), combo))` = n_t(c(list(blank), combo)) ,
`n_tf(c(list(blank), combo))` = n_tf(c(list(blank), combo)) ,
`NULL %.in.% abc` = NULL %.in% abc ,
`NULL %.mf.% abc` = NULL %.mf.% abc ,
`one_bl(c(blank, letters))` = one_bl(c(blank, letters)) ,
`one_dif("a", c(blank, NA, letters))` = one_dif("a", c(blank, NA, letters)) ,
`one_eq(NA, c(blank, NA, letters))` = one_eq(NA, c(blank, NA, letters)) ,
`one_f(c(list(blank), combo))` = one_f(c(list(blank), combo)) ,
`one_ge("a", c(blank, NA, letters))` = one_ge("a", c(blank, NA, letters)) ,
`one_gt("a", c(blank, NA, letters))` = one_gt("a", c(blank, NA, letters)) ,
`one_in(NULL, blank, combo)` = one_in(NULL, blank, combo) ,
`one_le("a", c(blank, NA, letters))` = one_le("a", c(blank, NA, letters)) ,
`one_lt("a", c(blank, NA, letters))` = one_lt("a", c(blank, NA, letters)) ,
`one_mf(NULL, blank, combo)` = one_mf(NULL, blank, combo) ,
`one_nav(c(blank, NA, letters))` = one_nav(c(blank, NA, letters)) ,
`one_nav(chr.mat)` = one_nav(chr.mat) ,
`one_okv(c(blank, NA, letters))` = one_okv(c(blank, NA, letters)) ,
`one_okv(chr.mat)` = one_okv(chr.mat) ,
`one_t(c(list(blank), combo))` = one_t(c(list(blank), combo)) ,
`one_tf(c(list(blank), combo))` = one_tf(c(list(blank), combo)) ,
`some_bl(c(blank, letters))` = some_bl(c(blank, letters)) ,
`some_dif("a", c(blank, NA, letters))` = some_dif("a", c(blank, NA, letters)),
`some_eq(NA, c(blank, NA, letters))` = some_eq(NA, c(blank, NA, letters)) ,
`some_f(c(list(blank), combo))` = some_f(c(list(blank), combo)) ,
`some_ge("a", c(blank, NA, letters))` = some_ge("a", c(blank, NA, letters)) ,
`some_gt("a", c(blank, NA, letters))` = some_gt("a", c(blank, NA, letters)) ,
`some_in(NULL, blank, combo)` = some_in(NULL, blank, combo) ,
`some_le("a", c(blank, NA, letters))` = some_le("a", c(blank, NA, letters)) ,
`some_lt("a", c(blank, NA, letters))` = some_lt("a", c(blank, NA, letters)) ,
`some_mf(NULL, blank, combo)` = some_mf(NULL, blank, combo) ,
`some_nav(c(blank, NA, letters))` = some_nav(c(blank, NA, letters)) ,
`some_nav(chr.mat)` = some_nav(chr.mat) ,
`some_okv(c(blank, NA, letters))` = some_okv(c(blank, NA, letters)) ,
`some_okv(chr.mat)` = some_okv(chr.mat) ,
`some_t(c(list(blank), combo))` = some_t(c(list(blank), combo)) ,
`some_tf(c(list(blank), combo))` = some_tf(c(list(blank), combo)) ,
`TRUE %.and.% 42` = TRUE %.and.% 42 ,
`TRUE %.and.% TRUE` = TRUE %.and.% TRUE ,
`TRUE %.nor.% 42` = TRUE %.nor.% 42 ,
`TRUE %.nor.% TRUE` = TRUE %.nor.% TRUE ,
`TRUE %.xor.% 42` = TRUE %.xor.% 42 ,
`TRUE %.xor.% TRUE` = TRUE %.xor.% TRUE ,
`TRUE %.or.% 42` = TRUE %.or.% 42 ,
`TRUE %.or.% TRUE` = TRUE %.or.% TRUE ,
`two_bl(c(blank, letters))` = two_bl(c(blank, letters)) ,
`two_dif("a", c(blank, NA, letters))` = two_dif("a", c(blank, NA, letters)) ,
`two_eq(NA, c(blank, NA, letters))` = two_eq(NA, c(blank, NA, letters)) ,
`two_f(c(list(blank), combo))` = two_f(c(list(blank), combo)) ,
`two_ge("a", c(blank, NA, letters))` = two_ge("a", c(blank, NA, letters)) ,
`two_gt("a", c(blank, NA, letters))` = two_gt("a", c(blank, NA, letters)) ,
`two_in(NULL, blank, combo)` = two_in(NULL, blank, combo) ,
`two_le("a", c(blank, NA, letters))` = two_le("a", c(blank, NA, letters)) ,
`two_lt("a", c(blank, NA, letters))` = two_lt("a", c(blank, NA, letters)) ,
`two_mf(NULL, blank, combo)` = two_mf(NULL, blank, combo) ,
`two_nav(c(blank, NA, letters))` = two_nav(c(blank, NA, letters)) ,
`two_nav(chr.mat)` = two_nav(chr.mat) ,
`two_okv(c(blank, NA, letters))` = two_okv(c(blank, NA, letters)) ,
`two_okv(chr.mat)` = two_okv(chr.mat) ,
`two_t(c(list(blank), combo))` = two_t(c(list(blank), combo)) ,
`two_tf(c(list(blank), combo))` = two_tf(c(list(blank), combo)) )
}
egfailsafe()
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.