Obter todas as funções de origem

No R, estou usando source()para carregar algumas funções:

source("functions.R")

É possível obter a lista de todas as funções definidas neste arquivo? Como nomes de funções. (Talvez source()ele próprio possa devolvê-lo de alguma forma?).

PS: O último recurso seria chamar a source()segunda vez como local({ source(); })e depois ls()executar funções internas e de filtro, mas isso é muito complicado - existe solução mais fácil e menos desajeitada?

Eu acho que a melhor maneira seria originar o arquivo em um ambiente temporário. Consulte esse ambiente para todas as funções e copie esses valores para o ambiente pai.

my_source <- function(..., local=NULL) {
  tmp <- new.env(parent=parent.frame())
  source(..., local = tmp)
  funs <- names(tmp)[unlist(eapply(tmp, is.function))]
  for(x in names(tmp)) {
    assign(x, tmp[[x]], envir = parent.frame())
  }
  list(functions=funs)
}

my_source("script.R")

É um pouco desajeitado, mas você pode observar alterações nos objetos antes e depois da sourcechamada dessa maneira.

    # optionally delete all variables
    #rm(list=ls())

    before <- ls()
    cat("f1 <- function(){}\nf2 <- function(){}\n", file = 'define_function.R')
    # defines these
    #f1 <- function() {}
    #f2 <- function() {}
    source('define_function.R')
    after <- ls()

    changed <- setdiff(after, before)
    changed_objects <- mget(changed, inherits = T)
    changed_function <- do.call(rbind, lapply(changed_objects, is.function))
    new_functions <- changed[changed_function]

    new_functions
    # [1] "f1" "f2"

Eu acho que esse regex captura quase todos os tipos de funções válidas (operador binário, funções de atribuição) e todos os caracteres válidos em um nome de função, mas eu posso ter perdido um caso extremo.

# lines <- readLines("functions.R")

lines <- c(
  "`%in%` <- function",
  "foo <- function",
  "foo2bar <- function",
  "`%in%`<-function",
  "foo<-function",
  ".foo <-function",
  "foo2bar<-function",
  "`foo2bar<-`<-function",
  "`foo3bar<-`=function",
  "`foo4bar<-` = function",
  "` d d` <- function", 
  "lapply(x, function)"
)
grep("^`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?\\s*(<-|=)\\s*function", lines)
#>  [1]  1  2  3  4  5  6  7  8  9 10
funs <- grep("^`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?\\s*(<-|=)\\s*function", lines, value = TRUE)
gsub("^(`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?).*", "\\1", funs)
#>  [1] "`%in%`"      "foo "        "foo2bar "    "`%in%`"      "foo"        
#>  [6] ".foo "       "foo2bar"     "`foo2bar<-`" "`foo3bar<-`" "`foo4bar<-`"

Se esse for seu próprio script, para que você tenha controle sobre como ele é formatado, uma simples convenção seria suficiente. Apenas verifique se o nome de cada função começa no primeiro caractere de sua linha e se a palavra functiontambém aparece nessa linha. Qualquer outro uso da palavra functiondeve aparecer em uma linha que começa com um espaço ou tabulação. Em seguida, uma solução de uma linha é:

sub(" .*", "", grep("^\\S.*function", readLines("myscript.R"), value = TRUE))

As vantagens dessa abordagem são que

• é muito simples . As regras são simplesmente declaradas e há apenas uma linha simples de código R necessária para extrair os nomes das funções. O Regex também é simples e, para um arquivo existente, é muito fácil verificar - apenas cumprimente a palavra functione verifique se cada ocorrência exibida segue a regra.

• não há necessidade de executar a fonte. É totalmente estático .

• em muitos casos, você não precisará alterar o arquivo de origem e, em outros, haverá alterações mínimas. Se você estiver escrevendo o script do zero, com isso em mente, é ainda mais fácil organizar.

Existem muitas outras alternativas ao longo da ideia de convenções. você pode ter um regex mais sofisticado ou adicionar # FUNCTIONno final da primeira linha de qualquer definição de função se estiver escrevendo o script do zero e depois cumprimentar essa frase e extrair a primeira palavra da linha, mas a principal sugestão aqui parece particularmente atraente devido à sua simplicidade e às outras vantagens listadas.

Teste

# generate test file
cat("f <- function(x) x\nf(23)\n", file = "myscript.R") 

sub(" .*", "", grep("^\\S.*function", readLines("myscript.R"), value = TRUE))
## [1] "f"

Isso adapta o código usado na postagem do meu comentário para procurar uma sequência de tokens (símbolo, operador de atribuição e depois função), e deve pegar todas as funções definidas. Não tenho certeza se é robusto como resposta do MrFlick, mas é outra opção:

source2 <- function(file, ...) {
  source(file, ...)
  t_t <- subset(getParseData(parse(file)), terminal == TRUE)
  subset(t_t, token == "SYMBOL" & 
           grepl("ASSIGN", c(tail(token, -1), NA), fixed = TRUE) & 
           c(tail(token, -2), NA, NA) == "FUNCTION")[["text"]]
}