I'm a bit weary of adding this kind of link between scales and stats tbh. It makes the code much harder to reason about. Is there anything in this you couldn't achieve with binned scale and geom_bar()

From the linked issue:

I can't for example add a geom_vline() to mark a specific date on the axis, since the vertical line would then be snapped into a bin by the scale transform.

Thanks, yes it's exactly that. A typical use case I'm working with is epidemic curves that are annotated with contextual events. To pick a random example online, something like this (but sometimes the date ranges incolved are shorter so snapping to the bin centre is a more significant change):

The main data is a histogram with date bins that are either epidemiological weeks (i.e. weeks with the boundary fixed to a specific day of the week depending on local concentions) or calendar months/years. Annotations refer to events on a specific day or are time series that might be binned differently. A binned scale would force all layers to use the same bins.

The follow.scale part of this change by itself could easily live in an extension, but the frozen breaks part is hard to do outside of ggplot.

Ah, I see... Sorry for driving by with a half-informed suggestion 🙈

I'm still very much against geoms/stats being able to control aspects of the scaling. This kind of flow of control could lead to incompatibility between layers etc (and make code harder to reason about)

The change I proposed is the opposite: scales influence stats. I get that it stretches the abstractions a bit unnaturally, though.

The status quo solution is to separately tell the scale and the stat to use the same bin/break width and offset. It's certainly doable when you understand the issue, but it tends to be brittle.

So I suppose a compromise could be tweaks to the way breaks and bins are specified (especially with date scales) so that there's a more discoverable way to control them with the same syntax? I've see a lot of cases where people worked out how to synchronise bin (binwidth=7) and break widths (date_breaks="week") but got stuck with the offsets.

My reading skills are obviously impaired this morning 🙈

I've found a different way to get the result I'm after without needing any changes to the scale internals. Essentially rather than the scales going out of their way to avoid updating breaks after the first time, the breaks function is memoised by wrapping it along with an environment. I previously thought that interior mutability in a function wouldn't be possible.

library(ggplot2)
#> 
#> Attaching package: 'ggplot2'
#> The following object is masked from 'package:base':
#> 
#>     is.element

set.seed(2024)
df <- data.frame(date = as.Date("2024-01-01") + rnorm(100, 0, 5))

StatBin2 <- ggproto(
  "StatBin2", StatBin,
  compute_panel = function(self, data, scales, breaks = NULL, ...) {
    breaks <- breaks %||% scales$x$get_transformation()$inverse(scales$x$get_breaks())
    ggproto_parent(StatBin, self)$compute_panel(data, scales, breaks = breaks, ...)
  }
)

p <- ggplot(df, aes(date)) + geom_histogram(stat = StatBin2)

p + scale_x_date(breaks = scales::breaks_width("2 week"))
#> `stat_bin2()` using `bins = 30`. Pick better value with `binwidth`.

(this bit as before, with breaks undesirably recomputed after scales are expanded)

breaks_cached <- function(breaks) {
  ggplot2::ggproto(
    "BreaksCached", NULL,
    fn = breaks,
    cached = NULL,
    get_breaks = function(self, limits) {
      if (is.null(self$cached)) self$cached <- self$fn(limits)
      self$cached
    }
  )$get_breaks
}

p + scale_x_date(breaks = breaks_cached(scales::breaks_width("2 week")))
#> `stat_bin2()` using `bins = 30`. Pick better value with `binwidth`.

^{Created on 2024-11-06 with reprex v2.1.1}

It's feasible for an extension to handle everything by providing its own version of each binning stat (which is a minor hassle to substitute in for the normal stats) along with breaks_cached().

Alternatively there could be a less invasive ggplot implementation with follow.scale on the binning stats and breaks_cached() in {scales}. It doesn't have to use ggproto - this also works:

breaks_cached <- function(f) {
  fn <- function(...) {
    if (is.null(.cache.env$cached)) {
      .cache.env$cached <- .cache.env$inner(...)
    }
    .cache.env$cached
  }
  e <- new.env()
  e$inner <- f
  e$cached <- NULL
  rlang::fn_env(fn)$.cache.env <- e
  fn
}

Does this approach feel better for ggplot?

I agree with Thomas that anything that alters the state of the scale is undesirable. While caching breaks technically alters state, I feel there is not really a way ggplot2 could enforce this, even if it wanted to, because a breaks function is entirely up to users to specify. For this reason, I think it may be feasible to give StatBin read-only access to the breaks (e.g. with get_breaks()). If users then use a cached function for breaks, we could assume they're doing this deliberately and take ownership of any consequences of that action (good and bad).

I've updated this based on my previous comment and fleshed it out a little with documentation. The breaks_cached helper could live in scales (using an alternative implementation) or left to an extension.

Does the follow.scale part look like something you'd take? It's useful, if a bit niche, even without breaks_cached as long as the scale's breaks are fixed. I would just need to add the equivalent feature to the other binning stats.

Thanks for the updates! I think aside from off/major/minor there should be a 4th option that would be the union of major and minor breaks. Do we need a separate follow.scale argument? Can't we use keywords like breaks = "major" that are invoked when is_string(breaks)?. I'm not convinced the cached breaks needs to live in ggplot2, this is perhaps more in the realm of the scales package. In addition, I'm unsure why the ggproto would be necessary there, as I imagine you can just take advantage of the closure property of functions instead.

Thanks for taking a look!

For sure, the param can be folded into the existing one if that isn't confusing.

I'm happy to see if the breaks helper fits in scales. Since it caches any function it's not even really specific to breaks, so maybe there's a better home for it (rlang?), just as long as ggplot can refer to it later in docs. As for why it uses ggproto... that was just the first thing I tried that worked. There's an alternative version in my comment above without ggproto that could probably be further simplified if I understood a bit better how closures work in R :)

Since it sounds like you're open to the general idea of this, I'll extend it to the other binning stats and clean it up as a proper PR.

Before you extend this to other bin calculations, I'd wait for #6212 to be merged.
Closures work by knowing about the environment they were created in. So in the following example, the inner function knows about the cache variable. For reference: https://adv-r.hadley.nz/environments.html#function-environments

cache_breaks <- function(breaks_fun) {
  cache <- NULL
  function(...) {
    if (is.null(cache)) {
      cache <<- breaks_fun(...)
    }
    cache
  }
}