Creating a Function in R that Takes a List as an Argument

===========================================================

In this article, we will explore the process of creating a function in R that takes a list as an argument. We will go through the steps involved in defining such a function, including data type conversions and handling errors.

Introduction to Functions in R

Functions are a fundamental concept in programming languages, including R. They allow us to group a set of statements together that can be executed multiple times with different inputs. In R, functions can take arguments, perform calculations or operations on those arguments, and return results.

Understanding the Problem Statement

The problem statement asks us to create a function called get_rad_wait_time_data that takes two arguments: data and months. The function should read in a file specified by data, clean its columns, perform calculations based on the data, and finally return the results.

Initial Code Review

The initial code provided is already quite extensive. It includes several steps such as reading in a file, cleaning columns, performing calculations, grouping data, and returning results. However, there are some areas where we can improve the function’s structure and readability.

Defining the Function with Two Arguments

To define our function with two arguments, data and months, we need to specify their types using R’s data typing system. Since we’re working with lists in this case, we don’t need to specify any particular type for these arguments.

get_rad_wait_time_data <- function(data, months) {
  # implementation of the function goes here
}

Handling Errors with Try-Catch Blocks

Try-catch blocks are used to handle errors that may occur during the execution of our function. We can use this block to catch and handle any exceptions that might be thrown.

tryCatch(
  # code that may throw an exception
  expr = {
    file.to.load <- tryCatch(file.choose(new = T), error = function(e) "")
    
    # implementation of the rest of the function
  },
  # block to handle errors
  error = function(e) {
    print("An error occurred")
  }
)

Defining Data Types and Handling Exceptions

In R, we can use several functions to convert data types. For example, as.list() is used to convert a list into a named list.

months <- as.list(months)

We should also handle exceptions that might occur during the execution of our function using try-catch blocks.

Reading in a File and Cleaning Columns

To read in a file and clean its columns, we can use R’s built-in functions such as read.csv() to read in a CSV file and clean_names() to rename column names.

df <- read.csv(file.to.load) %>% clean_names()

Performing Calculations on the Data

After reading in the data and cleaning its columns, we can perform calculations using various R functions such as mutate(), filter(), and group_by().

df_clean <- df %>%
  filter(!is.na(acc)) %>%
  select(mrn, step_start_time, step_end_time, step_from_to, wait_time) %>%
  mutate(
    step_start_time_clean = mdy_hms(step_start_time),
    step_end_time_clean = mdy_hms(step_end_time),
    elapsed_time = difftime(step_end_time_clean, step_start_time_clean, units = "mins"),
    # ...and so on...

Grouping Data and Returning Results

Finally, we can group the data using group_by() and return the results using various R functions.

df_clean <- df_clean %>%
  group_by(mrn, step_start_time_clean, step_end_time_clean) %>%
  mutate(proc_count = n(),
         avg_time_per_proc = round(elapsed_time_int / proc_count, 2))

Putting it All Together

Here’s the complete function:

get_rad_wait_time_data <- function(data, months) {
  # get file
  file.to.load <- tryCatch(file.choose(new = T), error = function(e) "")
  
  # Months
  months <- as.list(months)
  
  # read the file in and clean col names
  df <- read.csv(file.to.load) %>% clean_names()
  
  # clean file and mutate columns
  df_clean <- df %>%
    filter(!is.na(acc)) %>%
    select(mrn, step_start_time, step_end_time, step_from_to, wait_time) %>%
    mutate(
      step_start_time_clean = mdy_hms(step_start_time),
      step_end_time_clean = mdy_hms(step_end_time),
      elapsed_time = difftime(step_end_time_clean, step_start_time_clean, units = "mins"),
      elapsed_time_int = as.integer(elapsed_time),
      procedure_start_year = year(step_start_time_clean),
      procedure_start_month = month(step_start_time_clean),
      procedure_start_month_name = month(step_start_time_clean, label = T, abbr = T),
      procedure_start_day = day(step_start_time_clean),
      procedure_start_dow = wday(step_start_time_clean, label = T, abbr = T),
      procedure_start_hour = hour(step_start_time_clean),
      procedure_end_year = year(step_end_time_clean),
      procedure_end_month = month(step_end_time_clean),
      procedure_end_month_name = month(step_end_time_clean, label = T, abbr = T),
      procedure_end_day = day(step_end_time_clean),
      procedure_end_dow = wday(step_end_time_clean, label = T, abbr = T),
      procedure_end_hour = hour(step_end_time_clean)
    ) %>%
    filter(procedure_start_month_name %in% months) %>%
    filter(elapsed_time_int >= 0)
  
  dt <- data.table(df_clean)
  dt[, mrn := na.locf(mrn, fromLast = T, na.rm = F)]
  df_clean <- setDF(dt)
  
  df_clean <- df_clean %>%
    group_by(
      mrn,
      step_start_time_clean,
      step_end_time_clean
    ) %>%
    mutate(
      proc_count = n(),
      avg_time_per_proc = round(elapsed_time_int / proc_count, 2)
    )
  
  df_clean <- as.data.frame(df_clean)
  
  return(df_clean)
}

This function will read in a file specified by data, clean its columns, perform calculations based on the data, and finally return the results.

Conclusion

In this article, we have explored the process of creating a function in R that takes a list as an argument. We covered topics such as handling errors with try-catch blocks, defining data types, and performing calculations on the data.

Last modified on 2023-08-01