Chapter 24: R Functions

Part 1: What is a Function?

A function is a self-contained block of code that performs a specific task. It can take inputs (called arguments), process them, and return an output.

Why Use Functions?

1. Reusability: Write once, use many times

2. Organization: Break complex problems into smaller pieces

3. Debugging: Test each part independently

4. Readability: Give meaningful names to operations

5. Maintenance: Change code in one place, not everywhere

The Basic Syntax

Part 2: Your First Functions

A Very Simple Function

Output: [1] "Hello, world!"

Function with Parameters

Output:

Function with Return Value

Output:

Part 3: Understanding Return Values

Implicit vs. Explicit Return

In R, the last evaluated expression is automatically returned:

But it’s often clearer to use return():

Returning Multiple Values

Functions can only return one object, but that object can be a list containing multiple values:

Part 4: Parameter Types and Default Values

Default Parameter Values

You can give parameters default values that are used if the caller doesn’t provide them:

Output:

Named Arguments

You can specify arguments by name, which is especially useful when there are many parameters:

Part 5: Variable Scope

Understanding scope is crucial when working with functions. Variables inside functions are separate from variables outside.

Local vs. Global Variables

Output:

The Super Assignment Operator (<<-)

If you really need to modify a global variable from inside a function, use <<-:

Warning: Modifying global variables from inside functions is generally considered bad practice. It makes code harder to debug and understand.

Part 6: Practical Examples

Example 1: Temperature Converter

Example 2: Data Quality Report

Example 3: Statistical Summary Function

Part 7: Functions with Variable Arguments

The … (ellipsis) Argument

The ... allows functions to accept any number of additional arguments:

Passing … to Other Functions

Part 8: Recursive Functions

A function that calls itself is called recursive. This is useful for problems that can be broken into smaller, similar subproblems.

Example: Factorial

Example: Fibonacci Sequence

Example: Directory Tree

Part 9: Functions as Objects

In R, functions are first-class objects. You can assign them to variables, pass them as arguments, and return them from other functions.

Storing Functions in Lists

Function Factory (Function that Returns Functions)

Function that Takes Functions as Arguments

Part 10: Error Handling in Functions

Robust functions should handle errors gracefully.

Using stop() for Errors

Using warning() and message()

Comprehensive Error Handling with tryCatch

Part 11: Debugging Functions

Using browser() for Interactive Debugging

Using debug() and debugonce()

Adding Trace Information

Part 12: Best Practices

1. Use Descriptive Names

2. Keep Functions Small and Focused

3. Document Your Functions

4. Validate Inputs

Summary: The Function Philosophy

Functions are your tools for abstraction and reusability. Master these concepts:

1. Definition and calling – Creating and using functions

2. Parameters – Passing data into functions

3. Return values – Getting results out

4. Scope – Understanding variable visibility

5. Error handling – Making functions robust

6. Documentation – Making functions usable by others

Best practices:

• Give functions clear, descriptive names

• Keep functions focused on a single task

• Validate inputs at the beginning

• Document what the function does

• Return meaningful results

• Handle errors gracefully

• Test your functions thoroughly

When to write a function:

• You repeat the same code more than twice

• You need to perform a well-defined task

• You want to make your code more readable

• You’re building a reusable tool

• You need to encapsulate complexity

Functions transform you from a person who writes scripts to a person who builds tools. They’re the difference between cooking a meal once and creating a recipe that can be used forever.

Would you like me to elaborate on any specific aspect of functions or explore more advanced topics like functional programming, closures, or creating packages?