Hello plotly 4.0 (and above)

Formula mappings

In the past, you could use an expression to map (a function of) variable(s) in a data frame to visual attribute(s), but this no longer works. From now on, you’ll need to use a formula instead, which is basically an expression, but with a ~ prefixed. You won’t have to use a formula when referencing objects, but I recommend it, since it helps inform sensible axis/guide title defaults (e.g., compare the output of plot_ly(z = volcano) to plot_ly(z = ~volcano)).

library(plotly)
plot_ly(mtcars, x = mpg, y = sqrt(wt))
#> Error in plot_ly(mtcars, x = mpg, y = sqrt(wt)): object 'wt' not found
plot_ly(mtcars, x = ~mpg, y = ~sqrt(wt))

There are a number of technical reasons why imposing this change is a good idea. If you’re interested in the details, I recommend reading Hadley Wickham’s notes on non-standard evaluation, but here’s the gist of the situation:

1. Since formulas capture the environment in which they are created, we can be confident that evaluation rules are always be correct, no matter the context.
2. Formulas are much easier to program with compared to symbols. In particular, it makes writing custom functions around plot_ly() easier. Also, it’s fairly easy to convert a string to a formula (e.g., as.formula("~sqrt(wt)")). This trick can be quite useful when programming in shiny (and a variable mapping depends on an input value).

myPlot <- function(x, y) {
  plot_ly(mtcars, x = x, y = y, color = ~factor(cyl), colors = "Dark2")
}
myPlot(~mpg, ~disp)

Smarter defaults

Instead of always defaulting to a “scatter” trace, plot_ly() now infers a sensible trace type (and other attribute defaults) based on the information provided. These defaults are determined by inspecting the vector type (e.g., numeric/character/factor/etc) of positional attributes (e.g., x/y). For example, if we supply a discrete variable to x (or y), we get a vertical (or horizontal) bar chart:

subplot(
  plot_ly(diamonds, x = ~cut, color = ~clarity),
  plot_ly(diamonds, y = ~cut, color = ~clarity),
  margin = 0.07
) %>% hide_legend()

Or, if we supply two discrete variables to both x and y:

plot_ly(diamonds, x = ~cut, y = ~clarity)

Also, the order of categories on a discrete axis, by default, is now either alphabetical (for character strings) or matches the ordering of factor levels. This makes it easier to sort categories according to something meaningful, rather than the order in which the categories appear (the old default). If you prefer the old default, use layout(categoryorder = "trace")

library(dplyr)
# order the clarity levels by their median price
d <- diamonds %>%
  group_by(clarity) %>%
  summarise(m = median(price)) %>%
  arrange(m)
diamonds$clarity <- factor(diamonds$clarity, levels = d[["clarity"]])
plot_ly(diamonds, x = ~price, y = ~clarity, type = "box")

plot_ly() now initializes a plot

Previously plot_ly() always produced at least one trace, even when using add_trace() to add on more traces (if you’re familiar with ggplot2 lingo, a trace is similar to a layer). From now on, you’ll have to specify the type in plot_ly() if you want it to always produce a trace:

subplot(
  plot_ly(economics, x = ~date, y = ~psavert, type = "scatter") %>% 
    add_trace(y = ~uempmed) %>%
    layout(yaxis = list(title = "Two Traces")),
  plot_ly(economics, x = ~date, y = ~psavert) %>% 
    add_trace(y = ~uempmed) %>% 
    layout(yaxis = list(title = "One Trace")),
  titleY = TRUE, shareX = TRUE, nrows = 2
) %>% hide_legend()