A string (for example names of a data frame).

The desired target case, provided as one of the following:

• snake_case: "snake"

• lowerCamel: "lower_camel" or "small_camel"

• UpperCamel: "upper_camel" or "big_camel"

• ALL_CAPS: "all_caps" or "screaming_snake"

• lowerUPPER: "lower_upper"

• UPPERlower: "upper_lower"

There are five "special" cases available:

• "parsed": This case is underlying all other cases. Every substring a string consists of becomes surrounded by an underscore (depending on the parsing_option). Underscores at the start and end are trimmed. No lower or upper case pattern from the input string are changed.

• "mixed": Almost the same as case = "parsed". Every letter which is not at the start or behind an underscore is turned into lowercase. If a substring is set as an abbreviation, it will stay in upper case.

• "swap": Upper case letters will be turned into lower case and vice versa. Also case = "flip" will work. Doesn't work with any of the other arguments except unique_sep, empty_fill, prefix and postfix.

• "none": Neither parsing nor case conversion occur. This case might be helpful, when one wants to call the function for the quick usage of the other parameters. Works with sep_in, transliterations, sep_out, prefix, postfix, empty_fill and unique_sep.

• "internal_parsing": This case is returning the internal parsing (suppressing the internal protection mechanism), which means that alphanumeric characters will be surrounded by underscores. It should only be used in very rare use cases and is mainly implemented to showcase the internal workings of to_any_case()

character with (uppercase) abbreviations. This marks abbreviations with an underscore behind (in front of the parsing). Useful if parsing_option 1 is needed, but some abbreviations within the string need parsing_option 2. Use this feature with care: One letter abbreviations and abbreviations next to each other may not be handled correctly, since those cases would introduce ambiguity in parsing.

(short for separator input) A regex supplied as a character (if not NULL), which will be wrapped internally into stringr::regex(). All matches will be replaced by underscores (additionally to "_" and " ", for which this is always true). Underscores can later turned into another separator via sep_out.

An integer that will determine the parsing_option.

• 1: RRRStudio -> RRR_Studio

• 2: RRRStudio -> RRRS_tudio

• 3: parses like option 1 but suppresses "_" around non special characters. In this way case conversion won't apply after these characters. See examples.

• 4: parses like option 1, but digits directly behind/in front non-digits, will stay as is.

• any other integer <= 0: no parsing"

A character vector (if not NULL). The entries of this argument need to be elements of stringi::stri_trans_list() (like "Latin-ASCII", which is often useful) or names of lookup tables (currently only "german" is supported). In the order of the entries the letters of the input string will be transliterated via stringi::stri_trans_general() or replaced via the matches of the lookup table.

You should use this feature with care in case of case = "parsed", case = "internal_parsing" and case = "none", since for upper case letters, which have transliterations/replacements of length 2, the second letter will be transliterated to lowercase, for example Oe, Ae, Ss, which might not always be what is intended.

(short for separator output) String that will be used as separator. The defaults are "_" and "", regarding the specified case.

A string. If not NULL, then duplicated names will get a suffix integer in the order of their appearance. The suffix is separated by the supplied string to this argument.

A string. If it is supplied, then each entry that matches "" will be replaced by the supplied string to this argument.

prefix (string).

postfix (string).