required-no-defaults.qmd

# Required args shouldn't have defaults {#sec-required-no-defaults}

```{r}
#| include = FALSE
source("common.R")
```

## What's the pattern?

Required arguments shouldn't have defaults; optional arguments should have defaults.
In other words, an argument should have a default if and only if it's optional.

This simple convention ensures that you can tell which arguments are optional and which arguments are required from a glance at the function signature.
Otherwise you need to rely on a careful reading of documentation.
Additionally, if you don't follow this convention and want to provide helpful error messages, you'll need to implement them yourself rather than relying on R's defaults.

## What are some examples?

This is a straightforward convention that the vast majority of functions follow.
There are a few exceptions that exist in base R, mostly for historical reasons.
Here are a couple of examples:

-   In `sample()` neither `x` not `size` has a default value:

    ```{r}
    args(sample)
    ```

    This suggests that `size` is required, but it's actually optional:

    ```{r}
    sample(1:4)
    sample(4)
    ```

-   `lm()` does not have defaults for `formula`, `data`, `subset`, `weights`, `na.action`, or `offset`.

    ```{r}
    args(lm)
    ```

    But only `formula` is actually required:

    ```{r}
    x <- 1:5
    y <- 2 * x + 1 + rnorm(length(x))
    lm(y ~ x)
    ```

In the tidyverse, one function that fails to follow this pattern is `ggplot2::geom_abline()`, `slope` and `intercept` don't have defaults but are not required.
If you don't supply them they default to `slope = 1` and `intercept = 0`, *or* are taken from `aes()` if they're provided there.
This is a mistake caused by trying to have `geom_abline()` do too much --- it can be both used as an annotation (i.e. with a single `slope` and `intercept`) or used to draw multiple lines from data (i.e. with one line for each row).

## How do I use the pattern?

This pattern is generally easy to follow: if you don't use `missing()` it's very hard to do this by mistake.

## How do I remediate past mistakes?

If an argument is required, remove the default argument.
If an argument is optional, either set it to the default value, or if the computation is complicated, set it to `NULL` and then compute inside the body of the function.

## See also

There are some exceptions to this rule when some arguments are only required sometimes:

-   @sec-mutually-exclusive: mutually exclusive arguments shouldn't have defaults even though one is required.

-   @sec-compound-arguments: compound arguments allow one argument to occasionally take the place of multiple required arguments.