Error Handling and Objects

Advanced R Programming: Error Handling and Objects 🛡️

Imagine you’re a superhero with a magical safety net. No matter what goes wrong, you always land safely!

The Big Picture: Your Safety Net Toolkit

Think of R programming like building a LEGO castle. Sometimes pieces fall, sometimes things break. But what if you had:

• A safety net that catches falling pieces (try & tryCatch)
• A warning light you can turn on or off (Warning Suppression)
• A magnifying glass to find problems (Debugging Tools)
• A magic labeling system to organize everything (S3 Classes & Methods)

Let’s explore each one!

1. The try Function 🥅

What is it?

The try function is like saying: “Try to do this, but if it fails, don’t crash — just tell me what went wrong.”

Real Life Example

Imagine asking your friend to catch a ball:

• If they catch it → Great!
• If they drop it → No big deal, game continues!

Simple Code

# Without try - program CRASHES if error
result <- log(-1)  # Oops! Can't log negative

# With try - program CONTINUES
result <- try(log(-1), silent = TRUE)

# Check if something went wrong
if (inherits(result, "try-error")) {
  print("Oops! Something went wrong!")
} else {
  print(result)
}

Key Points

2. The tryCatch Function 🎣

What is it?

tryCatch is the upgraded version of try. It’s like having different plans for different problems!

Real Life Example

You’re making a sandwich:

• Plan A: Use bread (normal case)
• Plan B: If no bread, use crackers (error handler)
• Plan C: If out of butter, use jam (warning handler)
• Always: Wash your hands after (finally block)

Simple Code

safe_divide <- function(a, b) {
  tryCatch(
    # Try this first
    expr = {
      result <- a / b
      return(result)
    },
    # If error happens
    error = function(e) {
      print("Can't divide!")
      return(NA)
    },
    # If warning happens
    warning = function(w) {
      print("Something seems off...")
      return(NA)
    },
    # Always runs at the end
    finally = {
      print("Division attempt complete!")
    }
  )
}

safe_divide(10, 2)   # Works fine: 5
safe_divide(10, 0)   # Infinity with warning

The Flow

graph TD
    A["Start tryCatch"] --> B{Try Expression}
    B -->|Success| C["Return Result"]
    B -->|Error| D["Run Error Handler"]
    B -->|Warning| E["Run Warning Handler"]
    D --> F["Finally Block"]
    E --> F
    C --> F
    F --> G["Done!"]

3. Error Functions 🚨

What are they?

These are your alarm bells — ways to create and throw your own errors!

The Three Alarms

Simple Examples

# message() - Just FYI
check_age <- function(age) {
  message("Checking your age...")
  if (age < 0) stop("Age can't be negative!")
  if (age > 150) warning("That's really old!")
  return(paste("You are", age, "years old"))
}

check_age(25)   # Works fine
check_age(-5)   # STOPS with error
check_age(200)  # Shows warning, continues

Custom Error Conditions

# Create a special error type
my_error <- function(msg) {
  structure(
    list(message = msg, call = sys.call(-1)),
    class = c("my_custom_error", "error", "condition")
  )
}

# Use it
stop(my_error("Something specific went wrong!"))

4. Warning Suppression 🔇

What is it?

Sometimes R shows warnings that you already know about. It’s like a car beeping because you opened the door — annoying when you MEANT to do it!

How to Silence Warnings

# Method 1: suppressWarnings()
x <- suppressWarnings(log(-1))
# No warning shown, x = NaN

# Method 2: options() - turns off ALL warnings
options(warn = -1)  # Silence everything
log(-1)             # No warning
options(warn = 0)   # Back to normal

# Method 3: Within a function
quiet_sqrt <- function(x) {
  suppressWarnings(sqrt(x))
}
quiet_sqrt(-4)  # Returns NaN, no warning

Warning Levels

Pro Tip 💡

# Only suppress specific warnings
withCallingHandlers(
  expr = log(-1),
  warning = function(w) {
    if (grepl("NaN", w$message)) {
      invokeRestart("muffleWarning")
    }
  }
)

5. Debugging Tools 🔍

What are they?

Debugging tools are your detective kit to find and fix bugs!

The Detective Toolkit

Using browser()

mystery_function <- function(x) {
  step1 <- x + 10
  browser()  # PAUSE HERE - look around!
  step2 <- step1 * 2
  return(step2)
}

# When you call it, R pauses at browser()
# You can type: step1, x, n (next), c (continue)
mystery_function(5)

Using debug()

buggy_function <- function(a, b) {
  sum <- a + b
  product <- a * b
  return(sum / product)
}

# Turn on debugging
debug(buggy_function)
buggy_function(2, 3)  # Steps through each line

# Turn off debugging
undebug(buggy_function)

Using traceback()

# After an error, see the path
outer <- function() { inner() }
inner <- function() { stop("Bug here!") }

outer()       # Error!
traceback()   # Shows: outer() -> inner() -> stop()

Debug Flow

graph TD
    A["Error Happens"] --> B["Run traceback"]
    B --> C["Find Problem Function"]
    C --> D["Add browser or debug"]
    D --> E["Step Through Code"]
    E --> F["Find the Bug!"]
    F --> G["Fix and Remove Debug"]

6. S3 Classes 📦

What is it?

S3 is R’s simple way to create custom object types. Think of it like creating your own LEGO brick type!

Real Life Example

A “dog” is just a list with:

• A name
• An age
• A breed

But we LABEL it as “dog” so R knows what it is!

Creating S3 Classes

# Create a "dog" class
create_dog <- function(name, age, breed) {
  dog <- list(
    name = name,
    age = age,
    breed = breed
  )
  # Add the class label!
  class(dog) <- "dog"
  return(dog)
}

# Make a dog
my_dog <- create_dog("Buddy", 3, "Golden Retriever")
class(my_dog)  # "dog"

Check Class

# Different ways to check
class(my_dog)              # "dog"
inherits(my_dog, "dog")    # TRUE
is(my_dog, "dog")          # TRUE

7. S3 Methods 🎭

What is it?

S3 methods let the same function do different things based on what type of object you give it!

Real Life Example

When you say “speak”:

• A dog goes “Woof!”
• A cat goes “Meow!”
• A human says “Hello!”

Same word, different actions!

Creating S3 Methods

# The "speak" function for dogs
speak.dog <- function(x) {
  paste(x$name, "says: Woof!")
}

# The "speak" function for cats
speak.cat <- function(x) {
  paste(x$name, "says: Meow!")
}

# Create animals
my_dog <- create_dog("Buddy", 3, "Retriever")
my_cat <- list(name = "Whiskers", age = 2)
class(my_cat) <- "cat"

# Same function, different results!
speak(my_dog)  # "Buddy says: Woof!"
speak(my_cat)  # "Whiskers says: Meow!"

Method Naming Rule

functionName.className
     ↓           ↓
  speak    .    dog

8. Generic Functions 🎪

What is it?

A generic function is the ringmaster that decides which specific method to call based on the object’s class!

Built-in Examples

# print() is a generic function
print(1:5)           # Uses print.default
print(my_dog)        # Uses print.dog (if exists)

# summary() is a generic function
summary(c(1,2,3))    # Uses summary.default
summary(lm(...))     # Uses summary.lm

Creating Your Own Generic

# Step 1: Create the generic
speak <- function(x, ...) {
  UseMethod("speak")
}

# Step 2: Create a default (fallback)
speak.default <- function(x, ...) {
  "I don't know how to speak!"
}

# Step 3: Create class-specific methods
speak.dog <- function(x, ...) {
  paste(x$name, "says: Woof!")
}

speak.cat <- function(x, ...) {
  paste(x$name, "says: Meow!")
}

# Now it works!
speak(my_dog)         # "Buddy says: Woof!"
speak(my_cat)         # "Whiskers says: Meow!"
speak("random text")  # "I don't know how to speak!"

How It Works

graph TD
    A["Call speak x"] --> B{What class is x?}
    B -->|dog| C["speak.dog"]
    B -->|cat| D["speak.cat"]
    B -->|unknown| E["speak.default"]
    C --> F["Return result"]
    D --> F
    E --> F

Putting It All Together 🎯

Let’s create a complete example using EVERYTHING we learned!

# Create a "calculator" class with error handling
create_calculator <- function(name) {
  calc <- list(name = name, history = c())
  class(calc) <- "calculator"
  return(calc)
}

# Generic function
calculate <- function(x, ...) {
  UseMethod("calculate")
}

# Method with error handling
calculate.calculator <- function(x, a, op, b) {
  tryCatch(
    expr = {
      result <- switch(op,
        "+" = a + b,
        "-" = a - b,
        "*" = a * b,
        "/" = if(b == 0) stop("Can't divide by zero!") else a / b,
        stop("Unknown operation!")
      )
      message(paste(x$name, "calculated:", a, op, b, "=", result))
      return(result)
    },
    error = function(e) {
      warning(paste("Error:", e$message))
      return(NA)
    }
  )
}

# Print method
print.calculator <- function(x, ...) {
  cat("Calculator:", x$name, "\n")
}

# Use it!
my_calc <- create_calculator("SuperCalc")
calculate(my_calc, 10, "+", 5)   # 15
calculate(my_calc, 10, "/", 0)   # NA with warning

Quick Reference Card 📋

You Did It! 🎉

You now have the complete superhero toolkit for:

✅ Catching errors gracefully ✅ Creating custom warnings and messages ✅ Debugging like a detective ✅ Building your own object types ✅ Making functions that adapt to any object

Remember: Great programmers don’t write perfect code — they write code that handles imperfection gracefully!

“A program that never fails is just a program that hasn’t been tested enough.”

Go build something amazing! 🚀