R - tryCatch warning message being written to data

Question

What I'm trying to achieve

I'm trying to write my own 'impute' function in R with a tryCatch statement which: 1. outputs a warning/error message containing the function name so I can debug easier. 2. Raises a warning if the function runs ok but doesn't impute all the missing values.

ImputeVariables <- function(impute.var, impute.values, 
                        filter.var){
# function to impute values. 
# impute.var = variables with NAs
# impute.values = the missing value(s) to replace NAs, value labesl are levels
# filter.var = the variables to filter on. 
# filter.levels = the categories of filter.var
tryCatch({
    filter.levels <- names(impute.values)
    # Validation
    stopifnot(class(impute.var) == class(impute.values), 
             length(impute.values) > 0,
             sum(is.na(impute.values)) == 0)
    # Impute values
    for(level in filter.levels){
        impute.var[which(filter.var == level & is.na(impute.var))] <- 
            impute.values[level]
    }
    # Check if all NAs removed.  Throw warning if not. 
    if(sum(is.na(impute.var)) > 0){
        warning("Not all NAs removed")
    }
    # Return values
    return(impute.var)

}, 
    error = function(err) print(paste0("ImputeValues: ",err)),
    warning = function(war) print(paste0("ImputeValues: ",war))
)
}

impute.var and filter.var are vectors taken from a data.frame (they are vectors of Ages and Titles (e.g. 'Mr', 'Mrs') impute.values is a vector of the same type as impute.var but with labels taken from filter.var (i.e. is of the form c('Mr' = 30, 'Mrs' = 25...))

The problem

To check if my validation was working I supplied the function with a named vector of NAs, thusly:

ages <-   c(34, 22, NA, 17, 38, NA)
titles <- c("Mr", "Mr", "Mr", "Mrs", "Mrs", "Mrs")
ages.values <- c("Mr" = NA, "Mrs" = NA)

ages.new <- ImputeVariables(ages, ages.values, titles)

print(ages.new)

But it outputs the following:

 "ImputeValues: Error: class(impute.var) == class(impute.values) is not TRUE\n"
 "ImputeValues: Error: class(impute.var) == class(impute.values) is not TRUE\n"

The two lines are due to the function printing the ages.new vector and the following print statement printing ages.new (why?)

If I comment out the validation (the stopifnot function) then I just get:

"ImputeValues: simpleWarning in doTryCatch(return(expr), name, parentenv, handler): Not all NAs removed\n" 

What I'm asking

1. Why does the tryCatch block behave this way?
2. Is my validation and error handling strategy optimal (obviously without the bug)?

Many thanks for your time.

Rob

Answer 1

Thanks Oliver.

The working code is now:

 ImputeVariables <- function(impute.var, impute.values, 
                        filter.var){
# function to impute values. 
# impute.var = variables with NAs
# impute.values = the missing value(s) to replace NAs, value labesl are levels
# filter.var = the variables to filter on. 
# filter.levels = the categories of filter.var
tryCatch({
    filter.levels <- names(impute.values)
    # Validation
    stopifnot(class(impute.var) == class(impute.values), 
             length(impute.values) > 0,
             sum(is.na(impute.values)) == 0)
    # Impute values
    for(level in filter.levels){
        impute.var[which(filter.var == level & is.na(impute.var))] <- 
            impute.values[level]
    }
    # Check if all NAs removed.  Throw warning if not. 
    if(sum(is.na(impute.var)) > 0){
        warning("Not all NAs removed")
    }
    # Return values
    return(impute.var)

}, 
    error = function(err) stop(paste0("ImputeValues: ",err)),
    warning = function(war) {
        message(paste0("ImputeValues: ",war))
        return(impute.var)}
)
}

Answer 2

This is essentially two different problems. The first problem is that print statements within a function do not print to the terminal, they print to the scope of the function. As an example:

> foo <- function(){
     print("bar")
  }
> foo()
[1] "bar"

It didn't print "bar" to your screen, it printed it to the function scope and then returned it. The reason it returned it was that it was the last value printed to the function scope, and so (lacking an explicit return() call) is the best candidate for what to return.

So, your code is (in sequence):

1. Throwing an error;
2. Not treating that error normally, but instead passing it into tryCatch's error handler, where it is printed;
3. Because it is the last thing printed within the function scope, since the return() statement is never hit due to the error, treating it as the return value from the function.

If you really want to continue processing the input values even if the stopifnot() conditions are met, you don't want a stopifnot(): however you structure that it's likely to prevent the return() call from running and cause weirdness. What I'd suggest is instead moving the conditional checks currently in stopifnot() outside the tryCatch, and sticking them in a series of if() statements that throw warnings (not errors) if they don't match up. tryCatch isn't really necessary in this situation.