Functions in R: Definition, Arguments and Return Values

Defining and Calling a Function

A function in R is a value, like a number or a string. You build one with the function keyword and pin it to a name with <-, the same way you'd store anything else in a variable:

square <- function(x) {
  x^2
}

print(square(4))
print(square(9))

The parts: function(x) declares one parameter named x, the braces hold the body, and calling square(4) runs the body with x set to 4. For a one-line body the braces are optional - square <- function(x) x^2 is the same function - but braces read better once the body grows.

Because a function is just a value, everything you know about variables applies: you can reassign it, pass it to another function, or store it in a list. That one fact powers half of idiomatic R, including the whole apply family.

Return Values: The Last Expression Wins

An R function returns whatever its last evaluated expression produces. There is no mandatory return statement:

fahrenheit_to_celsius <- function(f) {
  (f - 32) * 5 / 9
}

print(fahrenheit_to_celsius(212))
print(fahrenheit_to_celsius(32))

return() does exist, and it works the way you'd expect - it stops the function immediately and hands back its argument. Idiomatic R saves it for early exits: bailing out at the top when an input makes the rest of the work pointless. Pair it with if-else checks:

safe_divide <- function(a, b) {
  if (b == 0) {
    return(NA)   # early exit: division by zero has no useful answer
  }
  a / b          # normal path: last expression, returned automatically
}

print(safe_divide(10, 2))
print(safe_divide(10, 0))

Writing return(a / b) on the last line wouldn't be wrong, just noise. Reserve return() for the exits that happen early, and let the last expression speak for the normal path.

Default Values and Named Arguments

A parameter can carry a default value, declared with = in the parameter list. Callers who are happy with the default simply omit the argument:

greet <- function(name, greeting = "Hello", punctuation = "!") {
  paste0(greeting, ", ", name, punctuation)
}

print(greet("Ada"))
print(greet("Ada", "Hi"))
print(greet(punctuation = "?", name = "Ada", greeting = "Hey"))

The third call shows the other half of the story: named arguments. When you write name = "Ada" at the call site, position stops mattering - R matches by name first, then fills the remaining parameters by position. Two practical rules fall out of this:

• Put required parameters first and defaulted ones after them, so positional calls stay natural.
• At the call site, name any argument that isn't obvious from position. greet("Ada", punctuation = "?") is clearer than making a reader count commas.

Passing Arguments Through with ...

The special parameter ... (pronounced "dots") means "any number of extra arguments." A function that declares ... can accept arguments it never listed and forward them to another function:

shout <- function(..., punctuation = "!") {
  words <- paste(..., sep = " ")
  paste0(toupper(words), punctuation)
}

print(shout("good", "morning"))
print(shout("wait", "for", "it", punctuation = "..."))

shout() doesn't know or care how many words you pass - it hands them all to paste(). Notice that punctuation comes after the dots: any parameter declared after ... can only be set by name, which is exactly what you want for options. This pass-through pattern is everywhere in base R - sapply(x, round, digits = 2) works because sapply forwards digits = 2 to round via its own ....

The cost of dots is that typos slip through silently: misspell punctuation as punctation and it just gets swallowed into ... instead of raising an error. Keep dot-using functions small.

Anonymous Functions

When a function is only needed once - typically as an argument to another function - you can skip the name entirely:

nums <- c(1, 2, 3, 4)

print(sapply(nums, function(x) x^2))
print(sapply(nums, \(x) x^2))

Both lines do the same thing. function(x) x^2 is the classic spelling; \(x) x^2 is the shorthand added in R 4.1, where \ stands in for the word function. They are identical in every way except keystrokes - the shorthand is not a different kind of function.

Use an anonymous function when the operation is a one-liner tied to one call site. The moment you paste the same lambda in two places, or it grows past one line, give it a name - a named function is testable and self-documenting.

Scoping: What a Function Can See

R uses lexical scoping: when a function needs a variable it can't find among its own parameters and local assignments, it looks in the environment where the function was defined - not where it was called. In practice that means a function can read variables from the script around it:

rate <- 0.1

add_tax <- function(price) {
  price * (1 + rate)   # rate is found in the surrounding script
}

print(add_tax(100))

change_inside <- function() {
  rate <- 0.5          # a new local variable - the outer rate is untouched
  rate
}

print(change_inside())
print(rate)

The flip side: assignment inside a function never leaks out. rate <- 0.5 inside change_inside creates a fresh local variable that dies when the function returns; the outer rate still prints 0.1. This is a feature - functions can't accidentally trample your workspace - but it surprises beginners who expect the inner assignment to stick. If a function needs to hand a result to the outside world, return it and assign at the call site. (There is a <<- operator that reaches outward; treat it as a code smell until you genuinely need it.)

A Worked Example

Here's the payoff pattern: notice yourself repeating three lines of analysis, wrap them in a function, reuse it. Say you keep summarizing vectors of measurements:

describe <- function(x, digits = 2) {
  out <- c(
    n    = length(x),
    min  = min(x),
    mean = mean(x),
    max  = max(x)
  )
  round(out, digits)
}

print(describe(c(3.14159, 2.71828, 1.41421)))
print(describe(c(10, 20, 30, 40), digits = 0))

Everything from this page is in there: a defaulted digits parameter, a named call overriding it, and a last expression (round(out, digits)) doing the returning. The function reads like a sentence, works on any numeric vector, and lives in one place when you decide to add a median.

What You Take Away

• name <- function(args) { body } creates a function; the last evaluated expression is its return value.
• return() is for early exits, not for the normal final line.
• Defaults are declared with = in the parameter list; named arguments make call sites order-independent and readable.
• ... accepts and forwards any extra arguments - powerful, but it hides typos.
• function(x) and \(x) are the same thing; use anonymous functions for one-off one-liners.
• Functions read variables from where they were defined; assignments inside them stay inside.

Next up: the apply family - the functions that take your functions and run them across whole vectors and lists.