Key Takeaway: R functions can return multiple values through various structures, with named lists being the most flexible and recommended approach. This article covers all techniques with practical examples, best practices, and tips for effective implementation.

Introduction

In R programming, functions are essential building blocks that allow for reusable and modular code. However, unlike some other programming languages, R functions can only return a single object. This limitation presents a challenge when you need to return multiple values or results from a function. Fortunately, R provides several elegant ways to work around this constraint, allowing you to effectively return multiple values by packaging them into a single composite object.

Whether you’re performing statistical analysis, data preprocessing, or building complex models, knowing how to properly return multiple values from your functions is crucial for writing clean, efficient, and maintainable code. This article explores the various techniques for returning multiple values in R, complete with real-world examples and best practices.

Understanding Function Returns in R

Before diving into specific methods, it’s important to understand how R functions fundamentally handle return values.

The Single Return Value Rule

In R, a function can only return a single object. This is a fundamental aspect of the language. When a function executes, it evaluates all expressions within its body, and the value of the last expression becomes the return value by default.

# Example of implicit return (last expression)
add_numbers <- function(a, b) {
  a + b  # This is implicitly returned
}

# Example of explicit return
add_numbers_explicit <- function(a, b) {
  return(a + b)
}

Both functions above achieve the same result, but the second one uses the explicit return() statement. While this rule might seem limiting, R’s rich data structures allow us to package multiple values into a single object, effectively working around this constraint.

Implicit vs. Explicit Returns

R supports two ways of returning values:

Implicit return: The value of the last evaluated expression is automatically returned
Explicit return: Using the return() function to specify what to return

For clarity and readability, especially in complex functions, using explicit return() statements is generally recommended .

Method 1: Using Lists to Return Multiple Values

Lists are the most common and flexible way to return multiple values from a function in R. A list can contain elements of different types and lengths, making it ideal for returning heterogeneous data.

Basic List Example

calculate_stats <- function(numbers) {
  if(!is.numeric(numbers)) {
    stop("Input must be numeric")
  }
  
  mean_val <- mean(numbers)
  median_val <- median(numbers)
  std_dev <- sd(numbers)
  
  return(list(mean = mean_val, median = median_val, sd = std_dev))
}

# Using the function
numbers <- c(10, 15, 20, 25, 30)
results <- calculate_stats(numbers)

# Accessing individual results
print(results$mean)    # 20

[1] 20

print(results$median)  # 20

[1] 20

print(results$sd)      # 7.905694

[1] 7.905694

In this example, the function calculate_stats() computes three statistical measures and returns them as a named list. The names provide clear labels for each value, making the returned data easy to understand and access.

Why Lists Work Well

Lists are particularly useful for returning multiple values because:

They can contain elements of different types (numbers, strings, vectors, even other lists)
Elements can be named for easy access and clarity
They can handle varying lengths of data
They maintain the structure of complex objects

Method 2: Named Lists for Enhanced Readability

Building on the basic list approach, using named lists significantly improves code readability and maintenance. Named lists provide clear labels for each returned value, making the function’s output self-documenting.

line_stats <- function(line) {
  is_question <- grepl("\\?", line)
  is_dialogue <- grepl("\"", line)
  word_count <- length(strsplit(line, "\\s+")[[1]])
  
  return(list(
    question = is_question,
    dialogue = is_dialogue,
    wc = word_count
  ))
}

ex1 <- "The Voice said, \"This is no place as you understand place.\""
ex1_stats <- line_stats(ex1)
print(ex1_stats)

$question
[1] FALSE

$dialogue
[1] TRUE

$wc
[1] 11

The names in the returned list (question, dialogue, and wc) provide immediate context about what each value represents, making your code much more maintainable.

Method 3: Vectors for Simple Return Values

When all return values are of the same type (e.g., all numeric or all logical), vectors can be a simpler alternative to lists. However, they’re generally less flexible and can be more confusing when returning multiple different values.

calculate_circle_properties <- function(radius) {
  area <- pi * radius^2
  circumference <- 2 * pi * radius
  diameter <- 2 * radius
  
  # Return named vector
  return(c(area = area, circumference = circumference, diameter = diameter))
}

circle_props <- calculate_circle_properties(5)
print(circle_props)

         area circumference      diameter 
     78.53982      31.41593      10.00000

print(circle_props["area"])  # Access by name

    area 
78.53982

print(circle_props[1])       # Access by position

    area 
78.53982

While vectors can work for simple cases, they have limitations:

All elements must be of the same type
They can be less clear than lists for complex return values
Accessing elements by position is error-prone if the function changes

Method 4: Data Frames for Tabular Results

When your function processes multiple records or returns data that’s naturally tabular, data frames are an excellent choice. They provide a structured, table-like format that’s ideal for analysis and visualization.

analyze_text <- function(sentences) {
  n <- length(sentences)
  results <- data.frame(
    sentence = sentences,
    char_count = integer(n),
    word_count = integer(n),
    is_question = logical(n),
    stringsAsFactors = FALSE
  )
  
  for(i in 1:n) {
    results$char_count[i] <- nchar(sentences[i])
    results$word_count[i] <- length(unlist(strsplit(sentences[i], "\\s+")))
    results$is_question[i] <- grepl("\\?$", sentences[i])
  }
  
  return(results)
}

sentences <- c(
  "How does this function work?",
  "R makes data analysis easier.",
  "Return multiple values efficiently."
)

text_analysis <- analyze_text(sentences)
print(text_analysis)

                             sentence char_count word_count is_question
1        How does this function work?         28          5        TRUE
2       R makes data analysis easier.         29          5       FALSE
3 Return multiple values efficiently.         35          4       FALSE

Data frames are particularly useful when:

You’re processing multiple records
The output naturally fits a tabular structure
You plan to use the output for further data analysis or visualization
You need to maintain row-column relationships in the data

Method 5: Using Environments (Advanced)

For more advanced use cases, environments provide another way to return multiple values. Environments in R are containers that store objects, similar to lists, but with different behavior regarding object references.

create_counter <- function(start = 0) {
  # Create a new environment
  env <- new.env()
  
  # Initialize counter value
  env$value <- start
  
  # Define increment function
  env$increment <- function(by = 1) {
    env$value <- env$value + by
    invisible(env$value)
  }
  
  # Define get function
  env$get <- function() {
    env$value
  }
  
  # Define reset function
  env$reset <- function(value = 0) {
    env$value <- value
    invisible(env$value)
  }
  
  return(env)
}

# Usage example
counter <- create_counter(10)
counter$increment(5)
print(counter$get())  # 15

[1] 15

counter$reset()
print(counter$get())  # 0

[1] 0

Environments are particularly useful when:

You need to maintain state across multiple function calls
You want to implement closures or object-oriented patterns
You need to return functions that share data

While powerful, environments are generally considered more advanced and should be used judiciously for specific use cases.

Method 6: S3 and S4 Objects for Structured Returns

For more complex applications, especially when building larger packages or systems, returning S3 or S4 objects can provide a more formal structure to your function outputs.

S3 Objects Example

create_person <- function(name, age, occupation) {
  new_person <- list(
    name = name,
    age = age,
    occupation = occupation
  )
  
  # Assign S3 class
  class(new_person) <- "new_person"
  
  return(new_person)
}

# Define a method for printing person objects
print.new_person <- function(x, ...) {
  cat("Person:", x$name, "\n")
  cat("Age:", x$age, "\n")
  cat("Occupation:", x$occupation, "\n")
}

# Create and print a person
john <- create_person("John Smith", 35, "Data Scientist")
print(john)

Person: John Smith 
Age: 35 
Occupation: Data Scientist

S3 and S4 objects allow you to:

Define specialized behavior through methods
Enforce more structured data organization
Create object-oriented interfaces
Integrate with the broader R ecosystem that uses these systems

Method 7: Using Attributes for Additional Information

Another less conventional way to return additional values from a function is by attaching attributes to the returned object. This method allows you to store extra information with the primary result, although it might not always be as intuitive as the list or data frame approach. Experts on Stack Overflow have noted that setting attributes can be useful in some scenarios.

calculate_sqrt <- function(x) {
  if(x < 0) {
    result <- NaN
    attr(result, "error") <- "Cannot compute square root of negative number"
    attr(result, "input") <- x
    return(result)
  }
  
  result <- sqrt(x)
  attr(result, "original") <- x
  attr(result, "computed_on") <- Sys.time()
  return(result)
}

# Using the function with positive input
pos_result <- calculate_sqrt(16)
print(pos_result)  # Output: 4

[1] 4
attr(,"original")
[1] 16
attr(,"computed_on")
[1] "2025-05-05 08:29:58 EDT"

print(attr(pos_result, "original"))  # Output: 16

[1] 16

print(attr(pos_result, "computed_on"))  # Output: Current timestamp

[1] "2025-05-05 08:29:58 EDT"

# Using the function with negative input
neg_result <- calculate_sqrt(-4)
print(neg_result)  # Output: NaN

[1] NaN
attr(,"error")
[1] "Cannot compute square root of negative number"
attr(,"input")
[1] -4

print(attr(neg_result, "error"))  # Output: "Cannot compute square root of negative number"

[1] "Cannot compute square root of negative number"

When to Use Attributes

Attributes can be particularly useful in these scenarios:

Adding metadata to results: When you want to attach information about how or when a result was generated
Preserving original inputs: To maintain a reference to the input data along with the processed output
Error context: To provide additional information about errors without disrupting the main return value structure
Extending existing objects: When you want to add information to an object without changing its base type

Limitations of Using Attributes

While attributes can be useful, they come with some drawbacks:

Less discoverable: Users may not know to look for attributes unless properly documented
Can be lost in transformations: Many R functions strip attributes when transforming objects
Not as standardized: Unlike lists or data frames, there’s no consistent way to access all attributes at once
Less obvious in debugging: Attributes don’t always show up in simple print statements

If you decide to use attributes, make sure to document them thoroughly so users of your function know to look for them.

Best Practices for Returning Multiple Values

Based on the methods discussed, here are some best practices to follow when returning multiple values from R functions:

1. Use Named Lists for Clarity

Named lists are generally the best practice for returning multiple values, as they provide clear labels and can handle different data types.

# Good practice
analyze_data <- function(dataset) {
  return(list(
    summary = summary(dataset),
    missing = sum(is.na(dataset)),
    dimensions = dim(dataset)
  ))
}

# Less clear
analyze_data_poor <- function(dataset) {
  return(list(
    summary(dataset),
    sum(is.na(dataset)),
    dim(dataset)
  ))
}

2. Document Return Values Thoroughly

Proper documentation is crucial for functions that return multiple values. Use roxygen2-style comments to describe what each element in the return value represents.

#' Calculate basic statistics for a numeric vector
#'
#' @param x A numeric vector
#' @return A list containing:
#'   \item{mean}{The arithmetic mean}
#'   \item{median}{The median value}
#'   \item{sd}{The standard deviation}
#'   \item{range}{A vector containing the minimum and maximum values}
#' @examples
#' basic_stats(c(1, 2, 3, 4, 5))
basic_stats <- function(x) {
  return(list(
    mean = mean(x),
    median = median(x),
    sd = sd(x),
    range = range(x)
  ))
}

3. Use Consistent Return Structures

Maintain consistency in how your functions return multiple values, especially within the same package or project. If you use named lists in one function, use them throughout.

4. Match Return Type to Data Characteristics

Choose your return structure based on what makes the most sense for your data:

Use lists for heterogeneous data (different types)
Use data frames for tabular data
Use vectors only when all values are the same type and closely related
Use S3/S4 objects for complex structures requiring specialized methods

5. Error Handling for Robust Functions

Include proper error handling to ensure your functions fail gracefully and provide meaningful error messages.

calculate_stats <- function(data) {
  # Check if input is valid
  if(!is.numeric(data)) {
    stop("Input must be numeric")
  }
  
  if(length(data) == 0) {
    return(list(
      mean = NA,
      median = NA,
      sd = NA,
      message = "Empty input provided"
    ))
  }
  
  return(list(
    mean = mean(data),
    median = median(data),
    sd = sd(data)
  ))
}

calculate_stats(rnorm(100))

$mean
[1] 0.1894269

$median
[1] 0.1281316

$sd
[1] 1.070657

Performance Comparison of Return Methods

When choosing a method to return multiple values, performance considerations may come into play, especially for functions that are called frequently or that process large datasets.

Memory Usage

Lists: Generally higher memory overhead, especially for small values
Vectors: More memory-efficient for homogeneous data
Data Frames: Higher overhead than vectors but optimized for tabular operations
Environments: Potentially higher overhead due to their reference semantics

Speed of Access

Lists: Fast access by name, slower by position
Named Vectors: Similar to lists for named access
Data Frames: Optimized for column operations, slower for row operations
Environments: Generally slower for simple access patterns

For most cases, the performance differences are negligible compared to the benefits of code clarity and maintainability. Unless you’re working with very large datasets or in performance-critical contexts, prioritize readability and proper design over micro-optimizations.

Practical Example: Statistical Analysis Function

Let’s build a practical example that demonstrates good practices for returning multiple values. This function will analyze a dataset and return various statistical metrics.

analyze_dataset <- function(data, column = NULL) {
  # Validate inputs
  if(!is.data.frame(data)) {
    stop("Input must be a data frame")
  }
  
  # If column is specified, extract that column
  if(!is.null(column)) {
    if(!(column %in% names(data))) {
      stop("Specified column not found in data frame")
    }
    data_to_analyze <- data[[column]]
    col_name <- column
  } else {
    if(ncol(data) == 1) {
      data_to_analyze <- data[[1]]
      col_name <- names(data)[1]
    } else {
      stop("For multi-column data frames, you must specify a column name")
    }
  }
  
  # Check if data is numeric
  if(!is.numeric(data_to_analyze)) {
    stop("Data must be numeric for statistical analysis")
  }
  
  # Calculate statistics
  basic_stats <- list(
    column = col_name,
    mean = mean(data_to_analyze, na.rm = TRUE),
    median = median(data_to_analyze, na.rm = TRUE),
    sd = sd(data_to_analyze, na.rm = TRUE),
    range = range(data_to_analyze, na.rm = TRUE),
    missing = sum(is.na(data_to_analyze)),
    n = length(data_to_analyze)
  )
  
  # Calculate quantiles
  quantiles <- quantile(data_to_analyze, probs = c(0.25, 0.5, 0.75), na.rm = TRUE)
  
  # Create histogram data
  hist_data <- hist(data_to_analyze, plot = FALSE)
  
  # Return all results in a structured list
  return(list(
    basic_stats = basic_stats,
    quantiles = quantiles,
    histogram = hist_data
  ))
}

# Example usage
set.seed(123)
test_data <- data.frame(
  value = rnorm(100, mean = 10, sd = 2),
  group = sample(LETTERS[1:4], 100, replace = TRUE)
)

analysis <- analyze_dataset(test_data, "value")
print(analysis$basic_stats)

$column
[1] "value"

$mean
[1] 10.18081

$median
[1] 10.12351

$sd
[1] 1.825632

$range
[1]  5.381662 14.374666

$missing
[1] 0

$n
[1] 100

print(analysis$quantiles)

      25%       50%       75% 
 9.012292 10.123513 11.383638

This example demonstrates:

Proper input validation
Structured return values using nested lists
Clear naming of return elements
Inclusion of metadata (column name, sample size)
Multiple types of analysis in a single function

Practical Example: Data Processing Pipeline

Here’s another example showing how to return multiple values in a data processing pipeline:

preprocess_text_data <- function(text_vector) {
  if(!is.character(text_vector)) {
    stop("Input must be a character vector")
  }
  
  # Initialize results
  n <- length(text_vector)
  processed_text <- character(n)
  word_counts <- integer(n)
  stats <- list()
  skipped <- integer(0)
  
  # Process each text
  for(i in 1:n) {
    if(nchar(text_vector[i]) == 0) {
      skipped <- c(skipped, i)
      processed_text[i] <- ""
      word_counts[i] <- 0
      next
    }
    
    # Convert to lowercase
    current <- tolower(text_vector[i])
    
    # Remove punctuation
    current <- gsub("[[:punct:]]", "", current)
    
    # Remove extra whitespace
    current <- gsub("\\s+", " ", current)
    current <- trimws(current)
    
    # Store processed text
    processed_text[i] <- current
    
    # Count words
    word_counts[i] <- length(unlist(strsplit(current, "\\s+")))
  }
  
  # Calculate summary statistics
  stats$total_documents <- n
  stats$skipped <- length(skipped)
  stats$total_words <- sum(word_counts)
  stats$avg_words_per_doc <- mean(word_counts)
  
  # Create data frame of processed documents with metadata
  results_df <- data.frame(
    original = text_vector,
    processed = processed_text,
    word_count = word_counts,
    stringsAsFactors = FALSE
  )
  
  # Return all results
  return(list(
    processed_data = results_df,
    stats = stats,
    skipped_indices = skipped
  ))
}

# Example usage
sample_texts <- c(
  "The quick brown fox jumps over the lazy dog.",
  "",
  "R is a powerful language for data analysis!",
  "Multiple return values make functions more useful."
)

results <- preprocess_text_data(sample_texts)
print(results$stats)

$total_documents
[1] 4

$skipped
[1] 1

$total_words
[1] 24

$avg_words_per_doc
[1] 6

print(results$processed_data)

                                            original
1       The quick brown fox jumps over the lazy dog.
2                                                   
3        R is a powerful language for data analysis!
4 Multiple return values make functions more useful.
                                          processed word_count
1       the quick brown fox jumps over the lazy dog          9
2                                                            0
3        r is a powerful language for data analysis          8
4 multiple return values make functions more useful          7

This example shows:

A pipeline that processes text data
Returning both the processed data and metadata about the processing
Using a combination of data frame (for the main results) and list (for statistics)
Tracking and returning information about skipped items

Your Turn!

Now it’s your time to practice returning multiple values from R functions. Let’s create a function that analyzes a numeric vector and returns various metrics.

Exercise: Create a Function for Financial Data Analysis

Write a function called analyze_returns() that takes a numeric vector representing financial returns (percentages) and returns:

Basic statistics (mean, median, standard deviation)
Risk metrics (volatility, maximum drawdown)
A classification of the investment (low, medium, or high risk)

Click here for Solution!

analyze_returns <- function(returns) {
  # Validate input
  if(!is.numeric(returns)) {
    stop("Returns must be a numeric vector")
  }
  
  if(length(returns) < 3) {
    stop("Need at least 3 data points for meaningful analysis")
  }
  
  # Calculate basic statistics
  basic_stats <- list(
    mean = mean(returns, na.rm = TRUE),
    median = median(returns, na.rm = TRUE),
    sd = sd(returns, na.rm = TRUE)
  )
  
  # Calculate risk metrics
  # Annual volatility (assuming daily returns)
  volatility <- sd(returns, na.rm = TRUE) * sqrt(252)
  
  # Maximum drawdown
  cumulative_returns <- cumprod(1 + returns/100)
  max_drawdown <- 100 * (1 - min(cumulative_returns / cummax(cumulative_returns)))
  
  risk_metrics <- list(
    volatility = volatility,
    max_drawdown = max_drawdown,
    sharpe_ratio = if(volatility > 0) basic_stats$mean / volatility else NA
  )
  
  # Classify risk
  risk_class <- "medium"
  if(volatility < 10) risk_class <- "low"
  if(volatility > 20) risk_class <- "high"
  
  # Return all results
  return(list(
    statistics = basic_stats,
    risk = risk_metrics,
    classification = risk_class,
    n_observations = length(returns)
  ))
}

# Test the function
set.seed(42)
daily_returns <- rnorm(100, mean = 0.05, sd = 1.2)
analysis <- analyze_returns(daily_returns)
print(analysis)

$statistics
$statistics$mean
[1] 0.08901778

$statistics$median
[1] 0.1577561

$statistics$sd
[1] 1.249628


$risk
$risk$volatility
[1] 19.83724

$risk$max_drawdown
[1] 12.71379

$risk$sharpe_ratio
[1] 0.004487409


$classification
[1] "medium"

$n_observations
[1] 100

With this function:

We validate the input to ensure it’s numeric and has enough data points
We calculate basic statistics and risk metrics
We classify the risk level based on volatility
We return all results in a well-structured list

The returned list has clear, descriptive names for each component, making it easy to access specific results:

analysis$statistics$mean      # Mean return
analysis$risk$max_drawdown    # Maximum drawdown
analysis$classification       # Risk classification

Quick Takeaways and Key Points

Key principles for returning multiple values from R functions:

Named lists are the gold standard for returning multiple heterogeneous values
Data frames excel for tabular data and multiple observations
Document your return structures thoroughly to improve code usability
Be consistent in your approach to returns across related functions
Match the return structure to the data characteristics (lists for mixed types, data frames for tables)
Include proper error handling for robust function behavior
Use descriptive names for all elements in returned objects
Balance complexity and simplicity - don’t create overly complex return structures
Consider performance only after clarity - prioritize readability first
Test your functions thoroughly with edge cases to ensure they behave as expected

Common Pitfalls When Returning Multiple Values

When returning multiple values from functions in R, there are several common pitfalls to avoid:

Using unnamed elements: Always name the elements in lists, vectors, or data frames that you return. Unnamed elements make code harder to understand and maintain.
Inconsistent return types: Avoid returning different types of objects depending on the function’s execution path. This creates unpredictable behavior for users of your function.
Poor documentation: Failing to document the structure of returned objects makes your functions difficult to use correctly.
Return structure mismatch: Choose return structures that match the natural organization of your data. Don’t force tabular data into lists or heterogeneous data into vectors.
Overcomplicating simple cases: For functions that return just 2-3 closely related values of the same type, a named vector might be simpler than a list.

Frequently Asked Questions

1. How do I access individual values from a function that returns multiple values?

For lists, you can use the $ operator or double square brackets:

result <- my_function()
value1 <- result$first_value
# or
value1 <- result[["first_value"]]

For named vectors:

result <- my_function()
value1 <- result["first_value"]

For data frames:

result <- my_function()
column1 <- result$column_name
# or
first_row <- result[1, ]

2. Can I return different types of objects depending on the function’s logic?

While technically possible, it’s generally not recommended as it makes your code less predictable. If you need conditional behavior, it’s better to:

Return a consistent structure with NA or placeholder values
Use a status field to indicate special conditions
Split into separate functions for different return types

3. What’s the most efficient way to return multiple values in R?

For small to medium-sized data:

Named lists are generally best for heterogeneous data
Vectors for homogeneous data of the same type
Data frames for tabular data

For very large datasets, consider specialized structures like data.table or tibble.

4. How do I document functions that return multiple values?

Use roxygen2-style comments to describe each component of your return value:

#' Calculate statistics for a dataset
#'
#' @param data A numeric vector
#' @return A list containing:
#'   \item{mean}{The arithmetic mean of the data}
#'   \item{median}{The median value of the data}
#'   \item{sd}{The standard deviation of the data}
#' @examples
#' calc_stats(c(1, 2, 3, 4, 5))
calc_stats <- function(data) {
  # Function code...
}

5. When should I use S3/S4 objects instead of simple lists for returns?

Consider using S3/S4 objects when:

You need specialized behavior (like custom print or plot methods)
You’re building a package with complex data structures
You want to enforce a specific object structure
You’re integrating with other code that expects S3/S4 objects

For simpler functions or scripts, lists are usually sufficient and more straightforward.

Conclusion

Returning multiple values from functions is a common requirement in R programming. While R functions can only return a single object, the language provides several elegant solutions for packaging multiple values into a single return object.

Named lists offer the most flexibility and clarity for heterogeneous data, while data frames excel at returning tabular results. For simpler cases with homogeneous data types, named vectors can be a concise option. More advanced applications might benefit from environments or S3/S4 objects.

When designing functions that return multiple values, prioritize clarity, consistency, and proper documentation. Choose your return structure to match your data characteristics, and ensure your functions fail gracefully with informative error messages.

By following the best practices outlined in this article, you can create R functions that return multiple values in a clear, consistent, and maintainable way, enhancing the usability and reliability of your code.

Engage!

Have you implemented any of these techniques in your R functions? Which method do you find most useful for your specific needs? Share your experiences in the comments below or on social media using the hashtag #RProgramming. Your insights could help other R programmers solve similar challenges!

References

Advanced R: Functions - Hadley Wickham’s comprehensive guide to R functions including return value handling.
R Documentation: Lists - Official R documentation on lists, the most versatile way to return multiple values.
The R Inferno - Patrick Burns’ guide to R programming pitfalls, including function design considerations.
Stack Overflow: How to Return Multiple Values in R - Community discussion on multiple return value techniques.
R Packages - Documentation - Guide to documenting functions with roxygen2 including return value documentation.

Happy Coding! 🚀

You can connect with me at any one of the below:

Telegram Channel here: https://t.me/steveondata

LinkedIn Network here: https://www.linkedin.com/in/spsanderson/

Mastadon Social here: https://mstdn.social/@stevensanderson

RStats Network here: https://rstats.me/@spsanderson

GitHub Network here: https://github.com/spsanderson

Bluesky Network here: https://bsky.app/profile/spsanderson.com

My Book: Extending Excel with Python and R here: https://packt.link/oTyZJ

You.com Referral Link: https://you.com/join/EHSLDTL6