When providing a function for a breaks argument, specifying a vector of labels of the right ultimate length trips an error.

[BajczA475]

I may have found an issue, or I may just be missing something. When I supply a function as the input to scale_x_continuous's breaks argument like so:

#THIS RUNS
ggplot(iris, aes(x = Sepal.Length, y = Petal.Length)) +
    geom_point(aes(color = Sepal.Width)) +
    scale_x_continuous(breaks = scales::breaks_extended(n = 8))

I get a determinate output. In this case, there are clearly 8 breaks in the final graph, and this outcome never varies in length or the specific breaks arrived at.

However, if I then try to specify a vector of custom labels for those ultimate breaks:

#THIS THROWS AN ERROR
ggplot(iris, aes(x = Sepal.Length, y = Petal.Length)) +
    geom_point(aes(color = Sepal.Width)) +
    scale_x_continuous(breaks = scales::breaks_extended(n = 8),
                       labels = as.character(1:8))

This throws an error that "breaks" and "labels" have different lengths.

I had suspected that this might be because of the probing steps that ggplot2 takes to, e.g., assess whether the inputs to labels and breaks are functions or vectors, or else the tuning steps that occur to arrive at a final set of breaks when the breaks input was a function--at some point, I assumed the number of breaks != the number of labels and the error throws, even if the "final" set of breaks would actually be the right length.

But then I kept experimenting. I was able to avoid the error if I made the labels input a function also:

#THIS WORKS
ggplot(iris, aes(x = Sepal.Length, y = Petal.Length)) +
    geom_point(aes(color = Sepal.Width)) +
    scale_x_continuous(breaks = scales::breaks_extended(n = 8), labels = function(x) { paste0(x, "Can I?")})

But not when that function would result in a determinate vector of labels, even if the length of that vector would match the length of the breaks:

#THIS THROWS AN ERROR
ggplot(iris, aes(x = Sepal.Length, y = Petal.Length)) +
    geom_point(aes(color = Sepal.Width)) +
    scale_x_continuous(breaks = scales::breaks_extended(n = 8), labels = function(x) { LETTERS[1:8]} )

In this particular case, it seems if I supply a slightly larger vector of labels than I think I should need, I'm fine:

#THIS RUNS
ggplot(iris, aes(x = Sepal.Length, y = Petal.Length)) +
    geom_point(aes(color = Sepal.Width)) +
    scale_x_continuous(breaks = scales::breaks_extended(n = 8), labels = function(x) { LETTERS[1:9]} )

And that works even if I supply them as a vector and not as a function. So, I presume that means a single NA break is being assigned behind the scenes (at the beginning of the vector, since the first break gets assigned a B). Maybe because it's outside the limits of the scale? However, as the "end user," I'm not sure how I'm supposed to know what's happening to be able to provide the right length of vector for labels.

[teunbrand]

The data limits are 4.3-7.9, which after (default) scale expansion become 4.12-8.08.
Using the break function manually yields 9 breaks:

scales::breaks_extended(n = 8)(c(4.12, 8.08))
#> [1] 4.0 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0

The 4.0 is out of bounds, so it will get censored.
The breaks and labels are expected to be of the same length before the censoring step.
I think this example just exposes why it is a bad idea to set labels as a vector if you don't have exact control over breaks.
To quote Claus on this (#5208 (comment)):

I have long operated under the rule of thumb that one should never specify labels without specifying breaks.

[BajczA475]

Thanks for your response @tuenbrand, it was clarifying.

I think I am learning, then, that I cannot do what I want to do (or maybe shouldn't want to do what I want to do...?).

Here's the TL:DR: I have this function:

.endpoint_breaks = function(lims,
                            n = 5,
                            buffer_frac = 0.05) {

  pretty_fn   = scales::pretty_breaks(n) #YOINK THE PRETTY_BREAKS FUNCTION INTO MEMORY.
  original_lo = lims[1] #STASH ORIGINAL LIMITS
  original_hi = lims[2]
  lo          = original_lo #DUPLICATES TO MANIPULATE
  hi          = original_hi
  span        = diff(lims) #DATA RANGE
  buffer      = buffer_frac * span #WIGGLE ROOM

  #GO THRU SET NUMBER OF ITERATIONS.
  for (i in seq_len(50)) {
    brks = pretty_fn(c(lo, hi)) #SEE WHAT BREAKS WE'D START WITH.

    #CHECK--DO WE HAVE BREAKS SUFFICIENTLY CLOSE TO OR PAST THE ORIGINAL LIMIT VALUES?
    got_low  = min(brks) <= (original_lo + buffer)
    got_high = max(brks) >= (original_hi - buffer)

    if (got_low && got_high) { break } #IF SO, HALT
    if (!got_low) { lo = lo - buffer } #IF NOT, EXPAND THE CURRENT LIMITS A BIT AND TRY AGAIN.
    if (!got_high) { hi = hi + buffer }
  }

  #CLEANUP--MAKE SURE THE LIMITS AT AT LEAST A BIT PAST THE OUTERMOST FINAL BREAKS.
  limits = c(min(brks) - buffer,
             max(brks) + buffer)

  return(list(breaks = brks, limits = limits))
}

It's pretty unremarkable. It asks "Are there axis breaks+labels at, near, or past the range of the data, based on the incoming limits thereof (with the definition of "near" being controlled by the buffer_frac parameter)? If the answer is no, it fudges the limits out a bit and tries again until the answer is yes. Basically, I find "dangling axis ends" that lack labels to look incomplete and want my scales to not create them, if possible.

My hope (and I have more complete code that already does this) is to use continuous_scale() to build a scale_*_continuous variant that uses this function (or one like it) as its default for breaks and labels, something akin to like this:

#THIS RUNS AND YIELDS THE OUTCOMES I WOULD WANT.
ggplot(iris, aes(x = Sepal.Length, y = Petal.Length)) +
    geom_point() +
    scale_x_continuous(breaks = function(x) { .endpoint_breaks(x, 5, 0.05)$breaks}, 
                                    limits = function(x) { .endpoint_breaks(x, 5, 0.05)$limits})

The problem being that, if I then try to provide a vector of labels, it only works if I guess the right number of censored breaks and provide a padded vector accordingly.

The user would not be able to specify breaks or limits of their own if they used by variant--I'm 100% cool with! But ceding the ability to reformat/refurbish the labels too seems a bitter pill to swallow.

FWIW, I have an entirely different approach that uses a custom ggplot_add method to do all this, and it works like a charm. However, then I noticed this (https://ggplot2-book.org/extensions.html#sec-new-scales) and it made me think that it would be considered "more correct" to use continuous_scale, but if the one lets me manipulate labels and the other doesn't...

[teunbrand]

If you are in control of the breaks via a function, wouldn't it just make sense to filter out-of-bounds breaks at that point?
For example using the following as your scale breaks argument:

breaks = function(x) { 
    scales::discard(.endpoint_breaks(x, 5, 0.05)$breaks, x)
}

[BajczA475]

Huzzah, that seems to work! Thank you--I had tried to weed out NA breaks via various means, but I was doing so after censorship, so by then, the damage was done. I wasn't groking a way to do this early enough, I guess, but this seems to be it!