Arguments, Defaults and the Pipe

Back to the weekend R study group: the same five friends, Mara, Dev, Ada, Theo and Iris, with their quiz scores 58, 91, 73, 49 and 84 out of 100. In Lesson 3 you wrapped the grading rule into a function, grade(), and learned that everything a function needs should be passed in as an argument.

That was the strict version. This lesson makes your functions pleasant to actually call. You will give an argument a default so callers can leave it out, pass arguments by name so the order stops mattering, collect any extra arguments with the dots (...), and finally chain several steps together with the |> pipe so a calculation reads like a sentence instead of a riddle.

By the end of this lesson you will be able to:

• Give a function argument a default value so a caller can omit it
• Pass arguments by name to reorder them and skip past a defaulted one
• Use **...** to let a function accept extra arguments and forward them on
• Chain several function calls with the **|> pipe** and read them left to right

Prerequisites: you can [run R and assign with <-](R-Syntax-and-First-Objects.html), build and name a vector, use [if / else](Control-Flow-in-R.html) with comparisons like >=, and define a function with a name, arguments and a body.

A default lets the caller leave it out

In Lesson 3, the safe version of the pass/fail rule took the cut-off as an argument, so you had to spell it out on every call. But the pass mark is almost always 60. Forcing the caller to type 60 each time is busywork. A default value fixes that: write cutoff = 60 in the argument list, and that becomes the value R uses whenever the caller does not supply one.

The argument cutoff now has two faces. Leave it out and you get the sensible default (60). Supply it and your value wins. The default makes the common call short, grade(58), without taking the flexibility away.

One honest caveat: give defaults only to arguments that genuinely have a sensible fallback. score has none, every caller must provide a score, so it stays a plain argument with no default.

Add a default

Write is_pass so it takes a score and a cutoff that defaults to 60, and returns TRUE when the score reaches the cut-off. Fill in the default, then check. After this, is_pass(73) should give TRUE without your passing a cut-off at all.

is_pass <- function(score, cutoff = 60) {
  score >= cutoff
}
is_pass(73)
#> [1] TRUE

Name an argument and the order stops mattering

When you write grade(49, 80), how does R know that 49 is the score and 80 is the cut-off? By position: the first value you pass fills the first argument in the definition (score), the second value fills the second (cutoff). That is fine for one or two arguments, but it makes you remember the exact order.

Naming frees you from that. Write name = value and R binds by the name instead, so you can list the arguments in any order you like:

Naming earns its keep most when a function has several arguments and you want to skip one that has a default. Here report takes a score, a cutoff (default 60) and a label (default "student"). Name the label and you can jump straight to it, leaving cutoff on its default:

Under the hood R matches arguments in a fixed order: first every argument you gave by exact name, then a unique partial name, and only then the leftovers by position. The flow below is that order.

Where does the value land?

Using report <- function(score, cutoff = 60, label = "student") from the last step, a learner calls report(73, "Ada") hoping to label the row "Ada". Because "Ada" is not named, which argument does it fill?

... collects and forwards extra arguments

This week Ada was away, so her score is missing. In R a missing value is written NA. Now suppose you write a small helper to average the class. The moment one score is NA, plain mean() returns NA, because the average of "something unknown" is itself unknown:

The three dots, ..., are a catch-all argument. They collect any extra arguments the caller passes and let you forward them, untouched, to another function inside the body. Here you never mentioned na.rm when defining class_mean, yet the caller could still pass it, because ... scooped it up and mean(s, ...) passed it on. That is how thin wrapper functions stay flexible: they accept the inner function's options without having to list every one.

Forward the dots

Complete top_scores so it sorts the scores and forwards any extra arguments to sort() through the dots. Fill in the blank so that top_scores(scores, decreasing = TRUE) sorts from highest to lowest (sort() drops the NA on its own).

top_scores <- function(s, ...) {
  sort(s, ...)
}
top_scores(scores, decreasing = TRUE)
#>  Dev Iris Mara Theo
#>   91   84   58   49

|> chains steps into a sentence

Real work strings several functions together. Say you want the class average rounded to one decimal place: two steps, average then round. Written as ordinary nested calls, you have to read them inside out, starting in the middle and working outward:

Your eye has to find mean(...) buried inside round(...) first. With two steps it is bearable; with four it is a puzzle. The pipe operator |> rewrites the same calculation in reading order. It takes the value on its left and drops it into the first argument of the call on its right:

Now read it straight across, like a recipe: take scores, average them (ignoring the NA), then round the result to one decimal. Same answer, far clearer.

Recall from Lesson 3 that a function is a rule \(f\) that turns an input \(x\) into an output \(f(x)\). The pipe is just that application written left-first: x |> f() runs exactly \(f(x)\), and x |> f(y) runs \(f(x, y)\), with the piped value filling the first slot and y the rest.

Reading a pipe

The pipe feeds the left-hand value into the first argument on the right. Which plain, un-piped call is exactly the same as scores |> round(1)?

References

A few authoritative, free places to take this further:

• R for Data Science (2e), Functions - a hands-on chapter on defaults and on passing the dots through to another function.
• An Introduction to R: Named arguments and defaults - the official manual's section on exactly this, named matching and default values.
• Advanced R (2e), Function arguments - the rigorous treatment: how argument matching really works, lazy default evaluation, and ....
• The base R and magrittr pipes - a clear explainer of the native |> pipe, the placeholder, and how it differs from the older %>%.

Lesson 4 complete

Your functions are now comfortable to call. You gave an argument a default (cutoff = 60) so callers can leave it out; you passed arguments by name to reorder them and skip past a defaulted one; you used the dots (...) to collect extra arguments and forward them straight into mean() and sort(); and you chained steps with the **|> pipe**, turning a read-it-inside-out nest into a left-to-right sentence.

Next, Lesson 5: Environments and Scope. You have leaned on the idea that a function "finds" names like cutoff, but where exactly does R look, and in what order? You will see how R resolves a name, starting inside the function and working outward to the global workspace, and why that lookup rule is the last piece of how functions really work.