add vector methods for whole and decimal numbers in `standalone-types-check.R`

[EmilHvitfeldt]

In much the same way check_character() is the vector version of check_string(), and check_logical() is the vector version of check_bool(). It would be nice to have the same for check_number_whole() and check_number_decimal()

I would be happy to take stab at this

[lionel-]

With plural names like check_numbers_whole()? This seems reasonable, a PR is welcome! cc @hadley

[ijlyttle]

Would you consider check_numeric_whole()? It could fit a pattern of adjectives used for the vector version, and nouns for the scalar version (I know "character" is a stretch).

[hadley]

I think I'd prefer check_double() and check_integer() although this might be overly abusing the difference between what people mostly mean when they say integer vector and the precise technical definition.

[lionel-]

@hadley We already have the singular check_number_whole() and check_number_decimal()

[hadley]

@lionel- right, but I think vector and scalar checks are different enough that they can use different names/conventions (e.g. string vs character, bool vs logical).

[lionel-]

oh that makes sense. But I would be very surprised if check_integer() accepted double-storage vectors of whole numbers (or if check_double() accepted integer-storage vectors). So I'd prefercheck_numeric_whole() here which is more technically correct and also clearer in intent.

[lionel-]

Looking back on the existing predicates, I find it surprising that check_number_decimal(1L) doesn't fail.

I wonder if we should rename it to check_number(). "number" would be the scalar version of "numeric". And we'd have check_number_whole() and check_numeric_whole() as whole-number variants.

[khusmann]

Just submitted a PR for this, but it might be worth discussing the naming convention here a bit more:

Here's a matrix of our current check_*() vs is_*() functions:

Type	Single Check	Vector Check	Single is	Vector is
numeric (double or integer)	check_number	check_numeric		is.numeric (no rlang is_numeric!)
whole numeric	check_number_whole	check_numeric_whole	is_scalar_integerish	is_integerish
double			is_scalar_double	is_double
integer			is_scalar_integer	is_integer
string / character	check_string	check_character	is_string, is_scalar_character	is_character
bool / logical	check_bool	check_logical	is_bool, is_scalar_logical	is_logical

Personally, I like "integerish" instead of "numeric_whole" (Maybe it's because I come from a math background, but I expect whole number to be a non-negative integer).

What if we did something like the following? (Changes / additions in bold):

Type	Single Check	Vector Check	Single is	Vector is
numeric (double or integer)	check_number, check_scalar_numeric	check_numeric	is_number, is_scalar_numeric	is_numeric
whole numeric	check_scalar_integerish	check_integerish	is_scalar_integerish	is_integerish
double	check_scalar_double	check_double	is_scalar_double	is_double
integer	check_scalar_integer	check_integer	is_scalar_integer	is_integer
string / character	check_string, check_scalar_character	check_character	is_string, is_scalar_character	is_character
bool / logical	check_bool, check_scalar_logical	check_logical	is_bool, is_scalar_logical`	is_logical

[hadley]

@khusmann I'm pretty sure we don't want a scalar prefix because scalar_logical implies something slightly different to bool — namely in most cases that you're accepting a scalar, you don't want to accept missing values (at least by default). So while implemented as length-1 atomic vectors, I think these are genuinely different types and deserve different names.

[khusmann]

@hadley I think we're in agreement? I didn't mean to suggest we replace check_bool with check_scalar_logical, I was suggesting we have both checks, in the same way we have both is_bool and is_scalar_logical reflective of the distinct types.

The bigger picture I'm advocating for here is to have a check_*() method for each is_*() method. (It seems inconsistent to have check_numeric_whole vs check_integerish -- or are these distinct types as well?)

Alternatively, we could consider unifying checks via a single check_type(x, is_fn) function (e.g. check_type(foo, is_integerish))

[hadley]

Definitely don't want two duplicated checks here. I don't think we need a check function for every is_ function since our understanding of useful types has evolved since we created the is_ functions.

And I don't think a check_type() function is feasible without a lot of work because it's hard to get the error messages precisely correct unless you have all of the information in one place. And I don't think we want to embark on that sort of redesign at the moment.

[khusmann]

I don't think we need a check function for every is_ function since our understanding of useful types has evolved since we created the is_ functions.

Ah ok, that's key context for me; I've been treating the is_ fns as the sort of ground truth primitive definitions.

And I don't think a check_type() function is feasible without a lot of work because it's hard to get the error messages precisely correct unless you have all of the information in one place

Excellent point. I think I'm on the same page now, thanks for taking the time to get me up to speed.