# Readable Check Functions to Ensure Code Integrity

## Documentation for package ‘assertive’ version 0.3-6

- DESCRIPTION file.
- User guides, package vignettes and other documentation.
- Package NEWS.

## Help Pages

A B C D F G H I M N P R S T U

assertive-package | Readable check functions to ensure code integrity.

## -- A --

are_disjoint_sets | Set comparisons
are_identical | Are the inputs identical?
are_identical_legacy | Are the inputs identical?
are_intersecting_sets | Set comparisons
are_same_length | Are the inputs the same length/dimension?
are_same_length_legacy | Are the inputs the same length/dimension?
are_set_equal | Set comparisons
assertionError | Condition classes
assertionMessage | Condition classes
assertionWarning | Condition classes
assertive | Readable check functions to ensure code integrity.
assert_all_are_after | Is the input in the past/future?
assert_all_are_before | Is the input in the past/future?
assert_all_are_cas_numbers | Does the character vector contain CAS registry numbers?
assert_all_are_classes | Is the input the name of a (formally defined) class?
assert_all_are_credit_card_numbers | Does the character vector contain credit card numbers?
assert_all_are_current_packages | Is the installed version of a package current?
assert_all_are_date_strings | Does the character vector contain dates?
assert_all_are_dirs | Is the path a directory?
assert_all_are_divisible_by | Is the input divisible by a number?
assert_all_are_email_addresses | Does the character vector contain email addresses?
assert_all_are_empty_character | Does the input contain empty or missing strings?
assert_all_are_empty_files | Is a file too big or small?
assert_all_are_equal_to | How does the input relate to a value?
assert_all_are_even | Is the input divisible by a number?
assert_all_are_executable_files | Is the file accessible?
assert_all_are_existing | Does the variable exist? See 'is_existing'.
assert_all_are_existing_files | Does the file exist?
assert_all_are_ex_files | Is the file accessible?
assert_all_are_false | Is the input TRUE/FALSE/NA?
assert_all_are_finite | Are the inputs (in)finite?
assert_all_are_greater_than | How does the input relate to a value?
assert_all_are_greater_than_or_equal_to | How does the input relate to a value?
assert_all_are_hex_colors | Does the character vector contain hex colors?
assert_all_are_hex_colours | Does the character vector contain hex colors?
assert_all_are_honorifics | Is the string an honorific?
assert_all_are_identical_legacy | Are the inputs identical?
assert_all_are_imaginary | Is the input real/imaginary?
assert_all_are_infinite | Are the inputs (in)finite?
assert_all_are_in_closed_range | Is the input in range?
assert_all_are_in_future | Is the input in the past/future?
assert_all_are_in_left_open_range | Is the input in range?
assert_all_are_in_open_range | Is the input in range?
assert_all_are_in_past | Is the input in the past/future?
assert_all_are_in_range | Is the input in range?
assert_all_are_in_right_open_range | Is the input in range?
assert_all_are_ip_addresses | Does the character vector contain IP addresses?
assert_all_are_isbn_codes | Does the character vector contain ISBN book codes?
assert_all_are_less_than | How does the input relate to a value?
assert_all_are_less_than_or_equal_to | How does the input relate to a value?
assert_all_are_libraries | Is the directory a known R library?
assert_all_are_logical_strings | Does the string contain a number? See 'is_numeric_string'.
assert_all_are_matching_fixed | Does the string match a pattern? See 'is_matching_fixed'.
assert_all_are_matching_regex | Does the string match a pattern? See 'is_matching_fixed'.
assert_all_are_missing_or_empty_character | Does the input contain empty or missing strings?
assert_all_are_na | Is the input TRUE/FALSE/NA?
assert_all_are_nan | Is the input (not) NaN?
assert_all_are_negative | Is the input in range?
assert_all_are_negative_infinity | Are the inputs (in)finite?
assert_all_are_non_empty_character | Does the input contain empty or missing strings?
assert_all_are_non_empty_files | Is a file too big or small?
assert_all_are_non_missing_nor_empty_character | Does the input contain empty or missing strings?
assert_all_are_non_negative | Is the input in range?
assert_all_are_non_positive | Is the input in range?
assert_all_are_not_equal_to | How does the input relate to a value?
assert_all_are_not_false | Is the input TRUE/FALSE/NA?
assert_all_are_not_matching_fixed | Does the string match a pattern? See 'is_matching_fixed'.
assert_all_are_not_matching_regex | Does the string match a pattern? See 'is_matching_fixed'.
assert_all_are_not_na | Is the input TRUE/FALSE/NA?
assert_all_are_not_nan | Is the input (not) NaN?
assert_all_are_not_true | Is the input TRUE/FALSE/NA?
assert_all_are_numeric_strings | Does the string contain a number? See 'is_numeric_string'.
assert_all_are_odd | Is the input divisible by a number?
assert_all_are_on_os_path | Is the path on the OS path?
assert_all_are_percentages | Is the input in range?
assert_all_are_positive | Is the input in range?
assert_all_are_positive_infinity | Are the inputs (in)finite?
assert_all_are_proportions | Is the input in range?
assert_all_are_readable_files | Is the file accessible?
assert_all_are_real | Is the input real/imaginary?
assert_all_are_same_length | Are the inputs the same length/dimension?
assert_all_are_same_length_legacy | Are the inputs the same length/dimension?
assert_all_are_single_characters | Is the input a single character? See 'is_single_character'.
assert_all_are_true | Is the input TRUE/FALSE/NA?
assert_all_are_uk_car_licences | Is the string a valid UK car licence plate number?
assert_all_are_uk_car_licenses | Is the string a valid UK car licence plate number?
assert_all_are_uk_national_insurance_numbers | Is the string a valid UK national insurance number?
assert_all_are_uk_postcodes | Is the string a valid UK postcode?
assert_all_are_uk_telephone_numbers | Is the string a valid UK telephone number?
assert_all_are_us_social_security_numbers | Is the string a valid US SSN?
assert_all_are_us_telephone_numbers | Is the string a valid US telephone number?
assert_all_are_us_zip_codes | Is the string a valid US zip code?
assert_all_are_valid_variable_names | Is the string a valid variable name? See 'is_valid_variable_name'.
assert_all_are_whole_numbers | Is the input a whole number?
assert_all_are_writable_files | Is the file accessible?
assert_all_file_sizes_are_in_range | Is a file too big or small?
assert_all_numbers_are_whole_numbers | Is the input a whole number?
assert_all_strings_are_not_missing_nor_empty | Does the input contain empty or missing strings?
assert_any_are_after | Is the input in the past/future?
assert_any_are_before | Is the input in the past/future?
assert_any_are_cas_numbers | Does the character vector contain CAS registry numbers?
assert_any_are_classes | Is the input the name of a (formally defined) class?
assert_any_are_credit_card_numbers | Does the character vector contain credit card numbers?
assert_any_are_current_packages | Is the installed version of a package current?
assert_any_are_date_strings | Does the character vector contain dates?
assert_any_are_dirs | Is the path a directory?
assert_any_are_divisible_by | Is the input divisible by a number?
assert_any_are_email_addresses | Does the character vector contain email addresses?
assert_any_are_empty_character | Does the input contain empty or missing strings?
assert_any_are_empty_files | Is a file too big or small?
assert_any_are_equal_to | How does the input relate to a value?
assert_any_are_even | Is the input divisible by a number?
assert_any_are_executable_files | Is the file accessible?
assert_any_are_existing | Does the variable exist? See 'is_existing'.
assert_any_are_existing_files | Does the file exist?
assert_any_are_ex_files | Is the file accessible?
assert_any_are_false | Is the input TRUE/FALSE/NA?
assert_any_are_finite | Are the inputs (in)finite?
assert_any_are_greater_than | How does the input relate to a value?
assert_any_are_greater_than_or_equal_to | How does the input relate to a value?
assert_any_are_hex_colors | Does the character vector contain hex colors?
assert_any_are_hex_colours | Does the character vector contain hex colors?
assert_any_are_honorifics | Is the string an honorific?
assert_any_are_identical_legacy | Are the inputs identical?
assert_any_are_imaginary | Is the input real/imaginary?
assert_any_are_infinite | Are the inputs (in)finite?
assert_any_are_in_closed_range | Is the input in range?
assert_any_are_in_future | Is the input in the past/future?
assert_any_are_in_left_open_range | Is the input in range?
assert_any_are_in_open_range | Is the input in range?
assert_any_are_in_past | Is the input in the past/future?
assert_any_are_in_range | Is the input in range?
assert_any_are_in_right_open_range | Is the input in range?
assert_any_are_ip_addresses | Does the character vector contain IP addresses?
assert_any_are_isbn_codes | Does the character vector contain ISBN book codes?
assert_any_are_less_than | How does the input relate to a value?
assert_any_are_less_than_or_equal_to | How does the input relate to a value?
assert_any_are_libraries | Is the directory a known R library?
assert_any_are_logical_strings | Does the string contain a number? See 'is_numeric_string'.
assert_any_are_matching_fixed | Does the string match a pattern? See 'is_matching_fixed'.
assert_any_are_matching_regex | Does the string match a pattern? See 'is_matching_fixed'.
assert_any_are_missing_or_empty_character | Does the input contain empty or missing strings?
assert_any_are_na | Is the input TRUE/FALSE/NA?
assert_any_are_nan | Is the input (not) NaN?
assert_any_are_negative | Is the input in range?
assert_any_are_negative_infinity | Are the inputs (in)finite?
assert_any_are_non_empty_character | Does the input contain empty or missing strings?
assert_any_are_non_empty_files | Is a file too big or small?
assert_any_are_non_missing_nor_empty_character | Does the input contain empty or missing strings?
assert_any_are_non_negative | Is the input in range?
assert_any_are_non_positive | Is the input in range?
assert_any_are_not_equal_to | How does the input relate to a value?
assert_any_are_not_false | Is the input TRUE/FALSE/NA?
assert_any_are_not_matching_fixed | Does the string match a pattern? See 'is_matching_fixed'.
assert_any_are_not_matching_regex | Does the string match a pattern? See 'is_matching_fixed'.
assert_any_are_not_na | Is the input TRUE/FALSE/NA?
assert_any_are_not_nan | Is the input (not) NaN?
assert_any_are_not_true | Is the input TRUE/FALSE/NA?
assert_any_are_numeric_strings | Does the string contain a number? See 'is_numeric_string'.
assert_any_are_odd | Is the input divisible by a number?
assert_any_are_on_os_path | Is the path on the OS path?
assert_any_are_percentages | Is the input in range?
assert_any_are_positive | Is the input in range?
assert_any_are_positive_infinity | Are the inputs (in)finite?
assert_any_are_proportions | Is the input in range?
assert_any_are_readable_files | Is the file accessible?
assert_any_are_real | Is the input real/imaginary?
assert_any_are_same_length | Are the inputs the same length/dimension?
assert_any_are_same_length_legacy | Are the inputs the same length/dimension?
assert_any_are_single_characters | Is the input a single character? See 'is_single_character'.
assert_any_are_true | Is the input TRUE/FALSE/NA?
assert_any_are_uk_car_licences | Is the string a valid UK car licence plate number?
assert_any_are_uk_car_licenses | Is the string a valid UK car licence plate number?
assert_any_are_uk_national_insurance_numbers | Is the string a valid UK national insurance number?
assert_any_are_uk_postcodes | Is the string a valid UK postcode?
assert_any_are_uk_telephone_numbers | Is the string a valid UK telephone number?
assert_any_are_us_social_security_numbers | Is the string a valid US SSN?
assert_any_are_us_telephone_numbers | Is the string a valid US telephone number?
assert_any_are_us_zip_codes | Is the string a valid US zip code?
assert_any_are_valid_variable_names | Is the string a valid variable name? See 'is_valid_variable_name'.
assert_any_are_whole_numbers | Is the input a whole number?
assert_any_are_writable_files | Is the file accessible?
assert_any_file_sizes_are_in_range | Is a file too big or small?
assert_any_numbers_are_whole_numbers | Is the input a whole number?
assert_any_strings_are_not_missing_nor_empty | Does the input contain empty or missing strings?
assert_are_disjoint_sets | Set comparisons
assert_are_identical | Are the inputs identical?
assert_are_intersecting_sets | Set comparisons
assert_are_same_length | Are the inputs the same length/dimension?
assert_are_set_equal | Set comparisons
assert_engine | Throws an error if a condition isn't met
assert_has_all_attributes | Does the input have the specified attributes?
assert_has_any_attributes | Does the input have the specified attributes?
assert_has_arg | Does the current call have an argument? See 'has_arg'.
assert_has_colnames | Does the input have names?
assert_has_cols | Does the input have rows/columns?
assert_has_dimnames | Does the input have names?
assert_has_dims | Does the input have dimensions?
assert_has_duplicates | Does the input have duplicates?
assert_has_elements | Is the input empty/scalar?
assert_has_names | Does the input have names?
assert_has_no_duplicates | Does the input have duplicates?
assert_has_rownames | Does the input have names?
assert_has_rows | Does the input have rows/columns?
assert_has_slot | Does the S4 input have a slot?
assert_has_terms | Does the input have terms?
assert_have_same_dims | Are the inputs the same length/dimension?
assert_is_32_bit | What OS is running?
assert_is_32_bit_os | What OS is running?
assert_is_64_bit | What OS is running?
assert_is_64_bit_os | What OS is running?
assert_is_all_of | Does x belong to these classes?
assert_is_any_of | Does x belong to these classes?
assert_is_an_empty_string | Does the input contain empty or missing strings?
assert_is_an_integer | Is the input an integer?
assert_is_architect | Are you running R?
assert_is_array | Is the input an array or matrix?
assert_is_atomic | Is the input atomic/recursive/vector?
assert_is_a_bool | Is the input logical?
assert_is_a_complex | Is the input complex?
assert_is_a_double | Is the input numeric?
assert_is_a_missing_or_empty_string | Does the input contain empty or missing strings?
assert_is_a_non_empty_string | Does the input contain empty or missing strings?
assert_is_a_non_missing_nor_empty_string | Does the input contain empty or missing strings?
assert_is_a_number | Is the input numeric?
assert_is_a_raw | Is the input raw?
assert_is_a_string | Is the input of type character?
assert_is_batch_mode | How is R running?
assert_is_binding_locked | Is the binding of a variable locked? See 'is_binding_locked'.
assert_is_bsd | What OS is running?
assert_is_builtin_function | Is the input a closure, builtin or special function?
assert_is_bzfile_connection | Is the input a connection?
assert_is_call | Is the input a language object?
assert_is_character | Is the input of type character?
assert_is_closure_function | Is the input a closure, builtin or special function?
assert_is_comma_for_decimal_point | What does the current locale specify for the decimal point?
assert_is_complex | Is the input complex?
assert_is_condition | Is the input a condition?
assert_is_connection | Is the input a connection?
assert_is_current_r | Is this version of R up to date?
assert_is_data.frame | Is the input is a data.frame?
assert_is_data.table | Is the input a data.table?
assert_is_date | Is the input a date?
assert_is_debugged | Is the input function being debugged? See 'is_debugged'.
assert_is_diagonal_matrix | Is the input a diagonal matrix?
assert_is_double | Is the input numeric?
assert_is_emacs | Are you running R?
assert_is_empty | Is the input empty/scalar?
assert_is_empty_model | Is the input the empty model?
assert_is_environment | Is the input an environment?
assert_is_error | Is the input a condition?
assert_is_expression | Is the input a language object?
assert_is_externalptr | Is the input an external pointer?
assert_is_factor | Is the input a factor?
assert_is_fifo_connection | Is the input a connection?
assert_is_file_connection | Is the input a connection?
assert_is_formula | Is the input a formula?
assert_is_function | Is the input a function?
assert_is_gzfile_connection | Is the input a connection?
assert_is_identical_to_false | Is the input TRUE/FALSE/NA?
assert_is_identical_to_na | Is the input TRUE/FALSE/NA?
assert_is_identical_to_true | Is the input TRUE/FALSE/NA?
assert_is_identity_matrix | Is the input an identity matrix?
assert_is_if_condition | Is suitable to be used as an if condition See 'is_if_condition'.
assert_is_incomplete_connection | Is the input a connection?
assert_is_inherited_from | Does the object inherit from some class?
assert_is_integer | Is the input an integer?
assert_is_interactive | How is R running?
assert_is_internal_function | Is the input an internal function?
assert_is_language | Is the input a language object?
assert_is_leaf | Is the input a (dendrogram) leaf?
assert_is_linux | What OS is running?
assert_is_list | Is the input a list?
assert_is_loaded | Is the input DLL loaded? See 'is_loaded'.
assert_is_logical | Is the input logical?
assert_is_lower_triangular_matrix | Is the matrix upper/lower triangular?
assert_is_mac | What OS is running?
assert_is_macos_big_sur | What OS is running?
assert_is_macos_catalina | What OS is running?
assert_is_macos_high_sierra | What OS is running?
assert_is_macos_mojave | What OS is running?
assert_is_macos_sierra | What OS is running?
assert_is_matrix | Is the input an array or matrix?
assert_is_message | Is the input a condition?
assert_is_monotonic_decreasing | Is the vector monotonically increasing or decreasing?
assert_is_monotonic_increasing | Is the vector monotonically increasing or decreasing?
assert_is_mts | Is the input a time series?
assert_is_name | Is the input a language object?
assert_is_nested | Is the input atomic/recursive/vector?
assert_is_non_empty | Is the input empty/scalar?
assert_is_non_empty_model | Is the input the empty model?
assert_is_non_nested | Is the input atomic/recursive/vector?
assert_is_non_scalar | Is the input empty/scalar?
assert_is_not_null | Checks to see if the input is (not) null.
assert_is_null | Checks to see if the input is (not) null.
assert_is_numeric | Is the input numeric?
assert_is_of_dimension | Is the input empty/scalar?
assert_is_of_length | Is the input empty/scalar?
assert_is_one_sided_formula | Is the input a formula?
assert_is_open_connection | Is the input a connection?
assert_is_ordered | Is the input a factor?
assert_is_osx | What OS is running?
assert_is_osx_cheetah | What OS is running?
assert_is_osx_el_capitan | What OS is running?
assert_is_osx_jaguar | What OS is running?
assert_is_osx_leopard | What OS is running?
assert_is_osx_lion | What OS is running?
assert_is_osx_mavericks | What OS is running?
assert_is_osx_mountain_lion | What OS is running?
assert_is_osx_panther | What OS is running?
assert_is_osx_puma | What OS is running?
assert_is_osx_snow_leopard | What OS is running?
assert_is_osx_tiger | What OS is running?
assert_is_osx_yosemite | What OS is running?
assert_is_package_current | Is the installed version of a package current?
assert_is_pairlist | Is the input a list?
assert_is_period_for_decimal_point | What does the current locale specify for the decimal point?
assert_is_pipe_connection | Is the input a connection?
assert_is_posixct | Is the input a date?
assert_is_posixlt | Is the input a date?
assert_is_primitive | Is the input a function?
assert_is_qr | Is the input a QR decomposition of a matrix?
assert_is_r | Are you running R?
assert_is_raster | Is the input a raster?
assert_is_raw | Is the input raw?
assert_is_readable_connection | Is the input a connection?
assert_is_recursive | Is the input atomic/recursive/vector?
assert_is_ref_class_generator | Is the input an S4 object?
assert_is_ref_class_object | Is the input an S4 object?
assert_is_relistable | Is the input relistable?
assert_is_revo_r | Are you running R?
assert_is_rstudio | Are you running R?
assert_is_rstudio_current | Is RStudio the current version?
assert_is_rstudio_desktop | Is RStudio running in desktop or server mode?
assert_is_rstudio_server | Is RStudio running in desktop or server mode?
assert_is_r_alpha | Are you running R?
assert_is_r_beta | Are you running R?
assert_is_r_current | Is this version of R up to date?
assert_is_r_devel | Are you running R?
assert_is_r_patched | Are you running R?
assert_is_r_release | Are you running R?
assert_is_r_release_candidate | Are you running R?
assert_is_r_revised | Are you running R?
assert_is_r_slave | How is R running?
assert_is_r_stable | Are you running R?
assert_is_s3_generic | Is the input an S3 generic or method?
assert_is_s3_group_generic | Is the input an S3 generic or method?
assert_is_s3_internal_generic | Is the input an S3 generic or method?
assert_is_s3_method | Is the input an S3 generic or method?
assert_is_s3_primitive_generic | Is the input an S3 generic or method?
assert_is_S4 | Is the input an S4 object?
assert_is_s4 | Is the input an S4 object?
assert_is_s4_group_generic | Is the input an S3 generic or method?
assert_is_scalar | Is the input empty/scalar?
assert_is_set_equal | Set comparisons
assert_is_simple_error | Is the input a condition?
assert_is_simple_message | Is the input a condition?
assert_is_simple_warning | Is the input a condition?
assert_is_slave_r | How is R running?
assert_is_socket_connection | Is the input a connection?
assert_is_solaris | What OS is running?
assert_is_special_function | Is the input a closure, builtin or special function?
assert_is_square_matrix | Is the input a square matrix?
assert_is_stderr | Is the input a connection?
assert_is_stdin | Is the input a connection?
assert_is_stdout | Is the input a connection?
assert_is_stepfun | Is the input a function?
assert_is_subset | Set comparisons
assert_is_superset | Set comparisons
assert_is_symbol | Is the input a language object?
assert_is_symmetric_matrix | Is the input a symmetric matrix?
assert_is_table | Is the input a table?
assert_is_tbl | Is the input a tbl?
assert_is_tbl_cube | Is the input a tbl?
assert_is_tbl_df | Is the input a tbl?
assert_is_tbl_dt | Is the input a tbl?
assert_is_terminal_connection | Is the input a connection?
assert_is_text_connection | Is the input a connection?
assert_is_try_error | Is the input a condition?
assert_is_ts | Is the input a time series?
assert_is_tskernel | Is the input a time series?
assert_is_two_sided_formula | Is the input a formula?
assert_is_unix | What OS is running?
assert_is_unsorted | Is the input unsorted?
assert_is_unz_connection | Is the input a connection?
assert_is_upper_triangular_matrix | Is the matrix upper/lower triangular?
assert_is_url_connection | Is the input a connection?
assert_is_valid_r_code | Is the input valid R code? See 'is_valid_r_code'.
assert_is_vector | Is the input atomic/recursive/vector?
assert_is_visual_studio | Are you running R?
assert_is_warning | Is the input a condition?
assert_is_windows | What OS is running?
assert_is_windows_10 | What OS is running?
assert_is_windows_7 | What OS is running?
assert_is_windows_8 | What OS is running?
assert_is_windows_8.1 | What OS is running?
assert_is_windows_server_2008 | What OS is running?
assert_is_windows_server_2008_r2 | What OS is running?
assert_is_windows_server_2012 | What OS is running?
assert_is_windows_server_2012_r2 | What OS is running?
assert_is_windows_server_2016 | What OS is running?
assert_is_windows_server_2019 | What OS is running?
assert_is_windows_vista | What OS is running?
assert_is_writable_connection | Is the input a connection?
assert_is_xzfile_connection | Is the input a connection?
assert_is_zero_matrix | Is the input a zero matrix?
assert_r_can_build_translations | Can R find tools?
assert_r_can_compile_code | Can R find tools?
assert_r_can_find_java | Can R find tools?
assert_r_can_find_tools | Can R find tools?
assert_r_has_aqua_capability | Does R have a capability?
assert_r_has_cairo_capability | Does R have a capability?
assert_r_has_cledit_capability | Does R have a capability?
assert_r_has_fifo_capability | Does R have a capability?
assert_r_has_http_ftp_capability | Does R have a capability?
assert_r_has_iconv_capability | Does R have a capability?
assert_r_has_icu_capability | Does R have a capability?
assert_r_has_jpeg_capability | Does R have a capability?
assert_r_has_libcurl_capability | Does R have a capability?
assert_r_has_libxml_capability | Does R have a capability?
assert_r_has_long_double_capability | Does R have a capability?
assert_r_has_nls_capability | Does R have a capability?
assert_r_has_png_capability | Does R have a capability?
assert_r_has_profmem_capability | Does R have a capability?
assert_r_has_rprof_capability | Does R have a capability?
assert_r_has_sockets_capability | Does R have a capability?
assert_r_has_tcltk_capability | Does R have a capability?
assert_r_has_tiff_capability | Does R have a capability?
assert_r_has_x11_capability | Does R have a capability?

## -- B --

bapply | Wrapper to vapply that returns booleans.

## -- C --

call_and_name | Call a function, and give the result names.
cause | Get or set the '"cause"' attribute
cause<- | Get or set the '"cause"' attribute
changes | Important changes to assertive
character_to_list_of_integer_vectors | Convert a character vector to a list of integer vectors See 'character_to_list_of_integer_vectors'.
coerce_to | Coerce variable to a different class

## -- D --

DIM | Get the dimensions of an object
dont_stop | Run code without stopping

## -- F --

false | FALSE, with a cause of failure

## -- G --

get_name_in_parent | Get the name of a variable in the parent frame

## -- H --

has_any_attributes | Does the input have any attributes?
has_arg | Does the current call have an argument? See 'has_arg'.
has_arg_ | Does the current call have an argument? See 'has_arg'.
has_attributes | Does the input have the specified attributes?
has_colnames | Does the input have names?
has_cols | Does the input have rows/columns?
has_dimnames | Does the input have names?
has_dims | Does the input have dimensions?
has_duplicates | Does the input have duplicates?
has_elements | Is the input empty/scalar?
has_names | Does the input have names?
has_no_attributes | Does the input have any attributes?
has_no_duplicates | Does the input have duplicates?
has_rownames | Does the input have names?
has_rows | Does the input have rows/columns?
has_slot | Does the S4 input have a slot?
has_terms | Does the input have terms?
have_same_dims | Are the inputs the same length/dimension?

## -- I --

is2 | Alternative version of is
is_32_bit | What OS is running?
is_32_bit_os | What OS is running?
is_64_bit | What OS is running?
is_64_bit_os | What OS is running?
is_after | Is the input in the past/future?
is_an_empty_string | Does the input contain empty or missing strings?
is_an_integer | Is the input an integer?
is_architect | Are you running R?
is_array | Is the input an array or matrix?
is_atomic | Is the input atomic/recursive/vector?
is_a_bool | Is the input logical?
is_a_complex | Is the input complex?
is_a_double | Is the input numeric?
is_a_missing_or_empty_string | Does the input contain empty or missing strings?
is_a_non_empty_string | Does the input contain empty or missing strings?
is_a_non_missing_nor_empty_string | Does the input contain empty or missing strings?
is_a_number | Is the input numeric?
is_a_raw | Is the input raw?
is_a_string | Is the input of type character?
is_batch_mode | How is R running?
is_before | Is the input in the past/future?
is_binding_locked | Is the binding of a variable locked? See 'is_binding_locked'.
is_bsd | What OS is running?
is_builtin_function | Is the input a closure, builtin or special function?
is_bzfile_connection | Is the input a connection?
is_call | Is the input a language object?
is_cas_number | Does the character vector contain CAS registry numbers?
is_character | Is the input of type character?
is_class | Is the input the name of a (formally defined) class?
is_closure_function | Is the input a closure, builtin or special function?
is_comma_for_decimal_point | What does the current locale specify for the decimal point?
is_complex | Is the input complex?
is_condition | Is the input a condition?
is_connection | Is the input a connection?
is_credit_card_number | Does the character vector contain credit card numbers?
is_data.frame | Is the input is a data.frame?
is_data.table | Is the input a data.table?
is_date | Is the input a date?
is_date_string | Does the character vector contain dates?
is_debugged | Is the input function being debugged? See 'is_debugged'.
is_diagonal_matrix | Is the input a diagonal matrix?
is_dir | Is the path a directory?
is_divisible_by | Is the input divisible by a number?
is_double | Is the input numeric?
is_emacs | Are you running R?
is_email_address | Does the character vector contain email addresses?
is_empty | Is the input empty/scalar?
is_empty_character | Does the input contain empty or missing strings?
is_empty_file | Is a file too big or small?
is_empty_model | Is the input the empty model?
is_environment | Is the input an environment?
is_equal_to | How does the input relate to a value?
is_error | Is the input a condition?
is_error_free | Does the code run without throwing an error? See 'is_error_free'.
is_even | Is the input divisible by a number?
is_executable_file | Is the file accessible?
is_existing | Does the variable exist? See 'is_existing'.
is_existing_file | Does the file exist?
is_expression | Is the input a language object?
is_externalptr | Is the input an external pointer?
is_ex_file | Is the file accessible?
is_factor | Is the input a factor?
is_false | Is the input TRUE/FALSE/NA?
is_fifo_connection | Is the input a connection?
is_file_connection | Is the input a connection?
is_file_size_in_range | Is a file too big or small?
is_finite | Are the inputs (in)finite?
is_formula | Is the input a formula?
is_function | Is the input a function?
is_greater_than | How does the input relate to a value?
is_greater_than_or_equal_to | How does the input relate to a value?
is_gzfile_connection | Is the input a connection?
is_hex_color | Does the character vector contain hex colors?
is_hex_colour | Does the character vector contain hex colors?
is_honorific | Is the string an honorific?
is_identical_to_false | Is the input TRUE/FALSE/NA?
is_identical_to_na | Is the input TRUE/FALSE/NA?
is_identical_to_true | Is the input TRUE/FALSE/NA?
is_identity_matrix | Is the input an identity matrix?
is_if_condition | Is suitable to be used as an if condition See 'is_if_condition'.
is_imaginary | Is the input real/imaginary?
is_incomplete_connection | Is the input a connection?
is_infinite | Are the inputs (in)finite?
is_inherited_from | Does the object inherit from some class?
is_integer | Is the input an integer?
is_interactive | How is R running?
is_internal_function | Is the input an internal function?
is_in_closed_range | Is the input in range?
is_in_future | Is the input in the past/future?
is_in_left_open_range | Is the input in range?
is_in_open_range | Is the input in range?
is_in_past | Is the input in the past/future?
is_in_range | Is the input in range?
is_in_right_open_range | Is the input in range?
is_ip_address | Does the character vector contain IP addresses?
is_isbn10_code | Does the character vector contain ISBN book codes?
is_isbn13_code | Does the character vector contain ISBN book codes?
is_isbn_code | Does the character vector contain ISBN book codes?
is_language | Is the input a language object?
is_leaf | Is the input a (dendrogram) leaf?
is_less_than | How does the input relate to a value?
is_less_than_or_equal_to | How does the input relate to a value?
is_library | Is the directory a known R library?
is_linux | What OS is running?
is_list | Is the input a list?
is_loaded | Is the input DLL loaded? See 'is_loaded'.
is_logical | Is the input logical?
is_logical_string | Does the string contain a number? See 'is_numeric_string'.
is_lower_triangular_matrix | Is the matrix upper/lower triangular?
is_mac | What OS is running?
is_macos_big_sur | What OS is running?
is_macos_catalina | What OS is running?
is_macos_high_sierra | What OS is running?
is_macos_mojave | What OS is running?
is_macos_sierra | What OS is running?
is_matching_fixed | Does the string match a pattern? See 'is_matching_fixed'.
is_matching_regex | Does the string match a pattern? See 'is_matching_fixed'.
is_matrix | Is the input an array or matrix?
is_message | Is the input a condition?
is_missing_or_empty_character | Does the input contain empty or missing strings?
is_monotonic | Is the vector monotonically increasing or decreasing?
is_monotonic_decreasing | Is the vector monotonically increasing or decreasing?
is_monotonic_increasing | Is the vector monotonically increasing or decreasing?
is_mts | Is the input a time series?
is_na | Is the input TRUE/FALSE/NA?
is_name | Is the input a language object?
is_nan | Is the input (not) NaN?
is_negative | Is the input in range?
is_negative_infinity | Are the inputs (in)finite?
is_nested | Is the input atomic/recursive/vector?
is_non_empty | Is the input empty/scalar?
is_non_empty_character | Does the input contain empty or missing strings?
is_non_empty_file | Is a file too big or small?
is_non_empty_model | Is the input the empty model?
is_non_missing_nor_empty_character | Does the input contain empty or missing strings?
is_non_negative | Is the input in range?
is_non_nested | Is the input atomic/recursive/vector?
is_non_positive | Is the input in range?
is_non_scalar | Is the input empty/scalar?
is_not_equal_to | How does the input relate to a value?
is_not_false | Is the input TRUE/FALSE/NA?
is_not_matching_fixed | Does the string match a pattern? See 'is_matching_fixed'.
is_not_matching_regex | Does the string match a pattern? See 'is_matching_fixed'.
is_not_missing_nor_empty_character | Does the input contain empty or missing strings?
is_not_na | Is the input TRUE/FALSE/NA?
is_not_nan | Is the input (not) NaN?
is_not_null | Checks to see if the input is (not) null.
is_not_true | Is the input TRUE/FALSE/NA?
is_null | Checks to see if the input is (not) null.
is_numeric | Is the input numeric?
is_numeric_string | Does the string contain a number? See 'is_numeric_string'.
is_odd | Is the input divisible by a number?
is_of_dimension | Is the input empty/scalar?
is_of_length | Is the input empty/scalar?
is_one_sided_formula | Is the input a formula?
is_on_os_path | Is the path on the OS path?
is_open_connection | Is the input a connection?
is_ordered | Is the input a factor?
is_osx | What OS is running?
is_osx_cheetah | What OS is running?
is_osx_el_capitan | What OS is running?
is_osx_jaguar | What OS is running?
is_osx_leopard | What OS is running?
is_osx_lion | What OS is running?
is_osx_mavericks | What OS is running?
is_osx_mountain_lion | What OS is running?
is_osx_panther | What OS is running?
is_osx_puma | What OS is running?
is_osx_snow_leopard | What OS is running?
is_osx_tiger | What OS is running?
is_osx_yosemite | What OS is running?
is_package_current | Is the installed version of a package current?
is_pairlist | Is the input a list?
is_percentage | Is the input in range?
is_period_for_decimal_point | What does the current locale specify for the decimal point?
is_pipe_connection | Is the input a connection?
is_positive | Is the input in range?
is_positive_infinity | Are the inputs (in)finite?
is_posixct | Is the input a date?
is_posixlt | Is the input a date?
is_primitive | Is the input a function?
is_proportion | Is the input in range?
is_qr | Is the input a QR decomposition of a matrix?
is_r | Are you running R?
is_raster | Is the input a raster?
is_raw | Is the input raw?
is_readable_connection | Is the input a connection?
is_readable_file | Is the file accessible?
is_real | Is the input real/imaginary?
is_recursive | Is the input atomic/recursive/vector?
is_ref_class_generator | Is the input an S4 object?
is_ref_class_object | Is the input an S4 object?
is_relistable | Is the input relistable?
is_revo_r | Are you running R?
is_rstudio | Are you running R?
is_rstudio_current | Is RStudio the current version?
is_rstudio_desktop | Is RStudio running in desktop or server mode?
is_rstudio_server | Is RStudio running in desktop or server mode?
is_r_alpha | Are you running R?
is_r_beta | Are you running R?
is_r_current | Is this version of R up to date?
is_r_devel | Are you running R?
is_r_patched | Are you running R?
is_r_release | Are you running R?
is_r_release_candidate | Are you running R?
is_r_revised | Are you running R?
is_r_slave | How is R running?
is_r_stable | Are you running R?
is_s3_generic | Is the input an S3 generic or method?
is_s3_group_generic | Is the input an S3 generic or method?
is_s3_internal_generic | Is the input an S3 generic or method?
is_s3_method | Is the input an S3 generic or method?
is_s3_primitive_generic | Is the input an S3 generic or method?
is_S4 | Is the input an S4 object?
is_s4 | Is the input an S4 object?
is_s4_group_generic | Is the input an S3 generic or method?
is_scalar | Is the input empty/scalar?
is_set_equal | Set comparisons
is_simple_error | Is the input a condition?
is_simple_message | Is the input a condition?
is_simple_warning | Is the input a condition?
is_single_character | Is the input a single character? See 'is_single_character'.
is_slave_r | How is R running?
is_socket_connection | Is the input a connection?
is_solaris | What OS is running?
is_special_function | Is the input a closure, builtin or special function?
is_square_matrix | Is the input a square matrix?
is_stderr | Is the input a connection?
is_stdin | Is the input a connection?
is_stdout | Is the input a connection?
is_stepfun | Is the input a function?
is_subset | Set comparisons
is_superset | Set comparisons
is_symbol | Is the input a language object?
is_symmetric_matrix | Is the input a symmetric matrix?
is_table | Is the input a table?
is_tbl | Is the input a tbl?
is_tbl_cube | Is the input a tbl?
is_tbl_df | Is the input a tbl?
is_tbl_dt | Is the input a tbl?
is_terminal_connection | Is the input a connection?
is_text_connection | Is the input a connection?
is_true | Is the input TRUE/FALSE/NA?
is_try_error | Is the input a condition?
is_ts | Is the input a time series?
is_tskernel | Is the input a time series?
is_two_sided_formula | Is the input a formula?
is_uk_car_licence | Is the string a valid UK car licence plate number?
is_uk_car_license | Is the string a valid UK car licence plate number?
is_uk_national_insurance_number | Is the string a valid UK national insurance number?
is_uk_postcode | Is the string a valid UK postcode?
is_uk_telephone_number | Is the string a valid UK telephone number?
is_unix | What OS is running?
is_unsorted | Is the input unsorted?
is_unz_connection | Is the input a connection?
is_upper_triangular_matrix | Is the matrix upper/lower triangular?
is_url_connection | Is the input a connection?
is_us_social_security_number | Is the string a valid US SSN?
is_us_telephone_number | Is the string a valid US telephone number?
is_us_zip_code | Is the string a valid US zip code?
is_valid_r_code | Is the input valid R code? See 'is_valid_r_code'.
is_valid_variable_name | Is the string a valid variable name? See 'is_valid_variable_name'.
is_vector | Is the input atomic/recursive/vector?
is_visual_studio | Are you running R?
is_warning | Is the input a condition?
is_whole_number | Is the input a whole number?
is_windows | What OS is running?
is_windows_10 | What OS is running?
is_windows_7 | What OS is running?
is_windows_8 | What OS is running?
is_windows_8.1 | What OS is running?
is_windows_server_2008 | What OS is running?
is_windows_server_2008_r2 | What OS is running?
is_windows_server_2012 | What OS is running?
is_windows_server_2012_r2 | What OS is running?
is_windows_server_2016 | What OS is running?
is_windows_server_2019 | What OS is running?
is_windows_vista | What OS is running?
is_writable_connection | Is the input a connection?
is_writable_file | Is the file accessible?
is_xxx_for_decimal_point | What does the current locale specify for the decimal point?
is_xzfile_connection | Is the input a connection?
is_zero_matrix | Is the input a zero matrix?

## -- M --

merge_dots_with_list | Merge ellipsis args with a list.

## -- N --

na | NA, with a cause of failure
n_elements | Get the number of elements

## -- P --

parenthesise | Wrap a string in brackets
parenthesize | Wrap a string in brackets
print_and_capture | Print a variable and capture the output

## -- R --

r_can_build_translations | Can R find tools?
r_can_compile_code | Can R find tools?
r_can_find_java | Can R find tools?
r_can_find_tools | Can R find tools?
r_has_aqua_capability | Does R have a capability?
r_has_cairo_capability | Does R have a capability?
r_has_cledit_capability | Does R have a capability?
r_has_fifo_capability | Does R have a capability?
r_has_http_ftp_capability | Does R have a capability?
r_has_iconv_capability | Does R have a capability?
r_has_icu_capability | Does R have a capability?
r_has_jpeg_capability | Does R have a capability?
r_has_libcurl_capability | Does R have a capability?
r_has_libxml_capability | Does R have a capability?
r_has_long_double_capability | Does R have a capability?
r_has_nls_capability | Does R have a capability?
r_has_png_capability | Does R have a capability?
r_has_profmem_capability | Does R have a capability?
r_has_rprof_capability | Does R have a capability?
r_has_sockets_capability | Does R have a capability?
r_has_tcltk_capability | Does R have a capability?
r_has_tiff_capability | Does R have a capability?
r_has_x11_capability | Does R have a capability?

## -- S --

safe_deparse | Safe version of deparse
set_cause | Set a cause and return the input
strip_attributes | Strip all attributes from a variable
sys_get_locale | Get or set the system locale
sys_set_locale | Get or set the system locale

## -- T --

Truth | Is the input TRUE/FALSE/NA?

## -- U --

use_first | Only use the first element of a vector