Feature Request: Allow Increasing Order in `fct_infreq`

[drfloren]

Current implementation has fct_infreq locked in descending order. Request is to passthrough an argument to order allowing both directions.

Current version is:

fct_infreq <- function(f, w = NULL, ordered = NA) {
  f <- check_factor(f)
  w <- compute_weights(f, w)
  check_bool(ordered, allow_na = TRUE)

  lvls_reorder(f, order(w, decreasing = TRUE), ordered = ordered)
}

Example with update would be something like:

fct_infreq <- function(f, w = NULL, ordered = NA, desc = TRUE) {
  f <- check_factor(f)
  w <- compute_weights(f, w)
  check_bool(ordered, allow_na = TRUE)

  lvls_reorder(f, order(w, decreasing = desc), ordered = ordered)
}

[DavisVaughan]

Here's a motivating example for this from bluesky

https://fed.brid.gy/r/https://bsky.app/profile/did:plc:3zyo4iakhqs47bttjalqgbk7/post/3m22pqr23e22i
https://fed.brid.gy/r/https://bsky.app/profile/did:plc:3zyo4iakhqs47bttjalqgbk7/post/3m22qmiakhs2i

I think the important point is that it matches reorder()'s default, and also reorder() has a decreasing argument that allows the user to tweak this, so forcats probably should too

library(dplyr)
library(forcats)

set.seed(1234)

data <- tibble(
  x = sample(10, size = 100, replace = TRUE)
)

# Notice how we have quite a few ties in the counts,
# which must be broken somehow (order of appearance typically)
data |> count(x) |> arrange(n)
#> # A tibble: 10 × 2
#>        x     n
#>    <int> <int>
#>  1     2     6
#>  2     7     6
#>  3     1     7
#>  4     9     8
#>  5     5    10
#>  6     3    11
#>  7     8    11
#>  8    10    11
#>  9     4    13
#> 10     6    17

# In order of frequency, lowest first
# Ties are broken by order of appearance
data |>
  mutate(n = n(), .by = x) |>
  mutate(x = reorder(factor(x), n)) |>
  pull(x)
#>   [1] 10 6  5  9  5  6  4  2  7  6  10 6  4  8  4  4  5  8  4  8  3  4  10 5  2 
#>  [26] 8  4  3  7  9  3  6  4  8  10 2  5  6  1  6  8  3  6  1  1  9  8  10 1  8 
#>  [51] 10 6  3  9  3  6  9  10 7  6  8  9  3  3  2  5  8  10 7  6  4  9  7  3  6 
#>  [76] 5  8  1  4  7  3  9  4  1  6  6  10 6  5  5  1  2  6  10 2  5  4  3  10 4 
#> attr(,"scores")
#>  1  2  3  4  5  6  7  8  9 10 
#>  7  6 11 13 10 17  6 11  8 11 
#> Levels: 2 7 1 9 5 3 8 10 4 6

# In order of frequency, lowest first
# Ties are broken by (reversed) order of appearance (which is a little weird).
# It would be nice to have `fct_infreq(decreasing = FALSE)` which i think
# gives exactly what reorder() would give
data |>
  mutate(
    x = x |>
      factor() |>
      fct_infreq() |>
      fct_rev()
  ) |>
  pull(x)
#>   [1] 10 6  5  9  5  6  4  2  7  6  10 6  4  8  4  4  5  8  4  8  3  4  10 5  2 
#>  [26] 8  4  3  7  9  3  6  4  8  10 2  5  6  1  6  8  3  6  1  1  9  8  10 1  8 
#>  [51] 10 6  3  9  3  6  9  10 7  6  8  9  3  3  2  5  8  10 7  6  4  9  7  3  6 
#>  [76] 5  8  1  4  7  3  9  4  1  6  6  10 6  5  5  1  2  6  10 2  5  4  3  10 4 
#> Levels: 7 2 1 9 5 10 8 3 4 6

^{Created on 2025-09-30 with reprex v2.1.1}

[luifrancgom]

I want to add a motivating example in relation to why this is useful.

I am teaching a data visualization course for beginners using ggplot2.

When dealing with long category names, as in the following case:

# Load packages ----
library(ggplot2)
library(forcats)

# Visualization ----
ggplot(
  data = gss_cat,
  aes(x = partyid )
) +
geom_bar()

You might apply the following solution:

# Load packages ----
library(ggplot2)
library(forcats)

# Visualization ----
ggplot(
  data = gss_cat,
  aes(y = fct_rev(fct_infreq(partyid)))
) +
geom_bar()

In my country (Colombia), it is more natural to read a plot where categories are ordered from top to bottom, starting with the largest. However, the students often ask why 2 functions are needed to achieve this: fct_rev and fct_infreq

When learning a new programming language or a package, it is better to use as few functions as possible.