Как использовать функцию многоточия в R при написании собственной функции?

Я читал ответы и комментарии и вижу, что некоторые вещи не были упомянуты:

1. data.frame использует list(...) версию. Фрагмент кода:

   object <- as.list(substitute(list(...)))[-1L]
   mrn <- is.null(row.names)
   x <- list(...)
   

   object используется для волшебства с именами столбцов, но x используется для создания окончательного data.frame.
   Для использования неоцененного ... аргумента посмотрите код write.csv, где используется match.call.

2. Как вы пишете в комментариях, результат в ответе Дирка не является списком списков. Это список длиной 4, элементы которого относятся к типу language. Первый объект - это symbol - list, второй - выражение 1:10 и так далее. Это объясняет, почему нужен [-1L]: он удаляет ожидаемый symbol из предоставленных аргументов в ... (потому что это всегда список).
   Как заявляет Дирк, substitute возвращает «дерево синтаксического анализа неоцененного выражения».
   Когда вы вызываете my_ellipsis_function(a=1:10,b=11:20,c=21:30), затем ... «создает» список аргументов: list(a=1:10,b=11:20,c=21:30) и substitute делают его списком из четырех элементов:

   List of 4
   $  : symbol list
   $ a: language 1:10
   $ b: language 11:20
   $ c: language 21:30
   

   У первого элемента нет имени, и это [[1]] в ответе Дирка. Я добиваюсь таких результатов, используя:

   my_ellipsis_function <- function(...) {
     input_list <- as.list(substitute(list(...)))
     str(input_list)
     NULL
   }
   my_ellipsis_function(a=1:10,b=11:20,c=21:30)
   

3. Как и выше, мы можем использовать str, чтобы проверить, какие объекты находятся в функции.

   my_ellipsis_function <- function(...) {
       input_list <- list(...)
       output_list <- lapply(X=input_list, function(x) {str(x);summary(x)})
       return(output_list)
   }
   my_ellipsis_function(a=1:10,b=11:20,c=21:30)
    int [1:10] 1 2 3 4 5 6 7 8 9 10
    int [1:10] 11 12 13 14 15 16 17 18 19 20
    int [1:10] 21 22 23 24 25 26 27 28 29 30
   $a
      Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
      1.00    3.25    5.50    5.50    7.75   10.00 
   $b
      Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
      11.0    13.2    15.5    15.5    17.8    20.0 
   $c
      Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
      21.0    23.2    25.5    25.5    27.8    30.0 
   

   Ничего страшного. Давайте посмотрим substitute версию:

      my_ellipsis_function <- function(...) {
          input_list <- as.list(substitute(list(...)))
          output_list <- lapply(X=input_list, function(x) {str(x);summary(x)})
          return(output_list)
      }
      my_ellipsis_function(a=1:10,b=11:20,c=21:30)
       symbol list
       language 1:10
       language 11:20
       language 21:30
      [[1]]
      Length  Class   Mode 
           1   name   name 
      $a
      Length  Class   Mode 
           3   call   call 
      $b
      Length  Class   Mode 
           3   call   call 
      $c
      Length  Class   Mode 
           3   call   call 
   

   Это не то, что нам нужно. Для работы с такими объектами вам потребуются дополнительные приемы (как в write.csv).

Если вы хотите использовать ..., вам следует использовать его, как в ответе Шейна, list(...).

Вы можете преобразовать многоточие в список с помощью list(), а затем выполнить с ним свои операции:

> test.func <- function(...) { lapply(list(...), class) }
> test.func(a="b", b=1)
$a
[1] "character"

$b
[1] "numeric"

Итак, ваша get_list_from_ellipsis функция - не что иное, как list.

Допустимый вариант использования для этого - в случаях, когда вы хотите передать неизвестное количество объектов для работы (как в вашем примере c() или data.frame()). Однако не рекомендуется использовать ..., если вы знаете каждый параметр заранее, поскольку он добавляет некоторую двусмысленность и дальнейшее усложнение строке аргумента (и делает сигнатуру функции неясной для любого другого пользователя). Список аргументов - важная часть документации для пользователей функций.

В противном случае это также полезно в тех случаях, когда вы хотите передать параметры в подфункцию, не раскрывая их все в своих собственных аргументах функции. Это можно отметить в документации по функциям.

Просто добавлю к ответам Шейна и Дирка: интересно сравнить

get_list_from_ellipsis1 <- function(...)
{
  list(...)
}
get_list_from_ellipsis1(a = 1:10, b = 2:20) # returns a list of integer vectors

$a
 [1]  1  2  3  4  5  6  7  8  9 10

$b
 [1]  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

с участием

get_list_from_ellipsis2 <- function(...)
{
  as.list(substitute(list(...)))[-1L]
}
get_list_from_ellipsis2(a = 1:10, b = 2:20) # returns a list of calls

$a
1:10

$b
2:20

В нынешнем виде любая версия кажется подходящей для ваших целей в my_ellipsis_function, хотя первая явно проще.

Вы уже дали половину ответа. Рассмотреть возможность

R> my_ellipsis_function <- function(...) {
+   input_list <- as.list(substitute(list(...)))
+ }
R> print(my_ellipsis_function(a=1:10, b=2:20))
[[1]]
list

$a
1:10

$b
11:20

R> 

Таким образом, он взял два аргумента a и b из вызова и преобразовал их в список. Разве вы не об этом просили?

Это работает, как ожидалось. Ниже приводится интерактивный сеанс:

> talk <- function(func, msg, ...){
+     func(msg, ...);
+ }
> talk(cat, c("this", "is", "a","message."), sep=":")
this:is:a:message.
> 

То же самое, за исключением аргумента по умолчанию:

> talk <- function(func, msg=c("Hello","World!"), ...){
+     func(msg, ...);
+ }
> talk(cat,sep=":")
Hello:World!
> talk(cat,sep=",", fill=1)
Hello,
World!
>

Как видите, вы можете использовать это для передачи «дополнительных» аргументов функции внутри вашей функции, если значения по умолчанию не соответствуют вашим требованиям в конкретном случае.