How to handle the ... parameter when programming with dplyr

As noted in Konrad's answer, you can use rlang::enquos() to capture the ... arguments as a list of quosures, which you can then iterate over like any regular list. Each element can be injected back into dplyr verbs with !! and converted to a string name with rlang::aslabel():

library(dplyr)
myfunc  # A tibble: 150 × 7
#> # Groups:   Sepal.Length [35]
#>    Sepal.Length Sepal.Width Petal.Length Petal.Width Species Sepal.Widthmean
#>                                                
#>  1          5.1         3.5          1.4         0.2 setosa               3.5
#>  2          4.9         3            1.4         0.2 setosa               3  
#>  3          4.7         3.2          1.3         0.2 setosa               3.2
#>  4          4.6         3.1          1.5         0.2 setosa               3.1
#>  5          5           3.6          1.4         0.2 setosa               3.6
#>  6          5.4         3.9          1.7         0.4 setosa               3.9
#>  7          4.6         3.4          1.4         0.3 setosa               3.4
#>  8          5           3.4          1.5         0.2 setosa               3.4
#>  9          4.4         2.9          1.4         0.2 setosa               2.9
#> 10          4.9         3.1          1.5         0.1 setosa               3.1
#> # ℹ 140 more rows
#> # ℹ 1 more variable: Sepal.Lengthmean 

Here, rlang::enquos(...) captures all ... arguments as unevaluated quosures, then iterating over the list gives you one quosure per variable. !!var injects the quosure back into dplyr verbs (groupby, mutate, etc.). rlang::aslabel(var) extracts the variable name as a string for naming new columns. And finally := is needed on the left-hand side of mutate when the column name is computed programmatically.

myfunc 
      mutate(across(!!var, mean, .names = "{.col}mean"))
  }, .init = data)
}