Forcing specific data types as arguments to a function

Question

I was just wondering if there was a way to force a function to only accept certain data types, without having to check for it within the function; or, is this not possible b

Answer 1

You could write a wrapper like the following:

check.types = function(classes, func) {
    n = as.name

    params = formals(func)
    param.names = lapply(names(params), n)

    handler = function() { }
    formals(handler) = params

    checks = lapply(seq_along(param.names), function(I) {
        as.call(list(n('assert.class'), param.names[[I]], classes[[I]]))
    })
    body(handler) = as.call(c(
        list(n('{')),
        checks,
        list(as.call(list(n('<-'), n('.func'), func))),
        list(as.call(c(list(n('.func')), lapply(param.names, as.name))))
    ))

    handler
}

assert.class = function(x, cls) {
    stopifnot(cls %in% class(x))
}

And use it like

f = check.types(c('numeric', 'numeric'), function(x, y) {
    x + y
})

> f(1, 2)
[1] 3

> f("1", "2")
Error: cls %in% class(x) is not TRUE

Made somewhat inconvenient by R not having decorators. This is kind of hacky and it suffers from some serious problems:

1. You lose lazy evaluation, because you must evaluate an argument to determine its type.

2. You still can't check the types until call time; real static type checking lets you check the types even of a call that never actually happens.

Since R uses lazy evaluation, (2) might make type checking not very useful, because the call might not actually occur until very late, or never.

The answer to (2) would be to add static type information. You could probably do this by transforming expressions, but I don't think you want to go there.

Answer 2

I've found stopifnot() to be highly useful for these situations as well.

x <- function(n) { 
stopifnot(is.vector(n) && length(n)==1)
print(n)
}

The reason it is so useful is because it provides a pretty clear error message to the user if the condition is false.

Answer 3

This is entirely possible using S3 classes. Your example is somewhat contrived in the context or R, since I can't think of a practical reason why one would want to create a class of a single value. Nonetheless, this is possible. As an added bonus, I demonstrate how the function addone can be used to add the value of one to numeric vectors (trivial) and character vectors (so A turns to B, etc.):

Start by creating a generic S3 method for addone, utlising the S3 despatch mechanism UseMethod:

addone <- function(x){
  UseMethod("addone", x)
}

Next, create the contrived class single, defined as the first element of whatever is passed to it:

as.single <- function(x){
  ret <- unlist(x)[1]
  class(ret) <- "single"
  ret
}

Now create methods to handle the various classes. The default method will be called unless a specific class is defined:

addone.default <- function(x) x + 1
addone.character <- function(x)rawToChar(as.raw(as.numeric(charToRaw(x))+1))
addone.single <- function(x)x + 1

Finally, test it with some sample data:

addone(1:5)
[1] 2 3 4 5 6

addone(as.single(1:5))
[1] 2
attr(,"class")
[1] "single"

addone("abc")
[1] "bcd"

---

Some additional information:

1. Hadley's devtools wiki is a valuable source of information on all things, including the S3 object system.

2. The S3 method doesn't provide strict typing. It can quite easily be abused. For stricter object orientation, have a look at S4 classes, reference based classesor the proto package for Prototype object-based programming.