How to get the list of in-built functions used within a function

Question

Lets say I have a function named Fun1 within which I am using many different in-built functions of R for different different processes. Then how can I get a list of in-built functions used inside this function Fun1

  Fun1 <- function(x,y){
  sum(x,y)
  mean(x,y)
  c(x,y)
  print(x)
  print(y)
  }

So My output should be like list of characters i.e. sum, mean, c, print. Because these are the in-built functions I have used inside function Fun1.

I have tried using grep function

 grep("\\(",body(Fun1),value=TRUE)
 # [1] "sum(x, y)"  "mean(x, y)" "c(x, y)"    "print(x)"   "print(y)"

It looks ok, but arguments should not come i.e. x and y. Just the list of function names used inside body of function Fun1 here.

So my overall goal is to print the unique list of in-built functions or any create functions inside a particular function, here Fun1.

Any help on this is highly appreciated. Thanks.

I imagine one would have to use string matching to do such a task (`grep`). e.g. `select %>% body() %>% toString()`. You are also going to want a list of the functions you are searching for. — zacdav, Sep 13 '16 at 07:24
Possible duplicate of [Finding out which functions are called within a given function](http://stackoverflow.com/questions/11872879/finding-out-which-functions-are-called-within-a-given-function) — 989, Sep 13 '16 at 09:11

Rich Scriven · Accepted Answer · 2016-09-23T17:08:51.133

You could use all.vars() to get all the variable names (including functions) that appear inside the body of Fun1, then compare that with some prepared list of functions. You mention in-built functions, so I will compare it with the base package object names.

## full list of variable names inside the function body
(vars <- all.vars(body(Fun1)[-1], functions = TRUE))
# [1] "sum"   "x"     "y"     "mean"  "c"     "print"

## compare it with the base package object names
intersect(vars, ls(baseenv()))
# [1] "sum"   "mean"  "c"     "print"

I removed the first element of the function body because presumably you don't care about {, which would have been matched against the base package list.

Another possibility, albeit a bit less reliable, would be to compare the formal arguments of Fun1 to all the variable names in the function. Like I said, likely less reliable though because if you make assignments inside the function you will end up with incorrect results.

setdiff(vars, names(formals(Fun1)))
# [1] "sum"   "mean"  "c"     "print"

These are fun though, and you can fiddle around with them.

please also include `setdiff` command too, and also how it is different from `intersect` I understand intersect command. — Sowmya S. Manian, Sep 13 '16 at 08:10
Also, any idea on what if I created a custom function inside a function, even that would come using `setdiff` right? but it wont show up when I `intersect` it with `base` package because it is my custom function. — Sowmya S. Manian, Sep 13 '16 at 08:12

score 5 · Answer 2 · answered Sep 13 '16 at 08:22

5

Access to the parser tokens is available with functions from utils.

tokens <- utils::getParseData(parse(text=deparse(body(Fun1))))
unique(tokens[tokens[["token"]] == "SYMBOL_FUNCTION_CALL", "text"])
[1] "sum"   "mean"  "c"     "print"

answered Sep 13 '16 at 08:22

Rorschach

31,301
5
78
129

zacdav · Answer 3 · 2016-09-13T07:43:42.453

2

This should be somewhat helpful - this will return all functions however.

func_list = Fun1 %>% 
  body() %>% # extracts function
  toString() %>% # converts to single string
  gsub("[{}]", "", .)  %>% # removes curly braces
  gsub("\\s*\\([^\\)]+\\)", "", .) %>% # removes all contents between brackets
  strsplit(",") %>% # splits strings at commas
  unlist() %>% # converts to vector
  trimws(., "both") # removes all white spaces before and after`

[1] "" "sum" "mean" "c" "print" "print"

> table(func_list)
func_list
          c  mean print   sum 
    1     1     1     2     1

This is extremely limited to your example... you could modify this to be more robust. It will fall over where a function has brackets nesting other functions etc.

edited Sep 13 '16 at 07:43

answered Sep 13 '16 at 07:35

zacdav

4,603
2
16
37

This would a good version by using `dplyr`. Thank you. This one too helped. I also wanted the basic version. I have reduced code to two steps. – Sowmya S. Manian Sep 13 '16 at 07:52
I also liked when you did use `table()`. – Sowmya S. Manian Sep 13 '16 at 07:58

score 1 · Answer 4 · answered Sep 13 '16 at 07:42

1

this is not so beautiful but working:

Fun1 <- function(x,y){
    sum(x,y)
    mean(x,y)
    c(x,y)
    print(x)
    print(y)
}


getFNamesInFunction <- function(f.name){
    f <- deparse(body(get(f.name)))
    f <- f[grepl(pattern = "\\(", x = f)]
    f <- sapply(X = strsplit(split = "\\(", x = f), FUN = function(x) x[1])
    unique(trimws(f[f != ""]))
}
getFNamesInFunction("Fun1")
[1] "sum"   "mean"  "c"     "print"

answered Sep 13 '16 at 07:42

cccmir

953
6
12

Wow, it works. One question why your `f.name` should be provided in quotes. – Sowmya S. Manian Sep 13 '16 at 07:44
i decided it will be better to pass function name rather then the function itself. – cccmir Sep 13 '16 at 07:46
No I mean how I would know that I have to provide the argument in quotes and not without quotes, or else there should be something inside the function to convert argument name to character. – Sowmya S. Manian Sep 13 '16 at 07:47
You could improve this by making it take only the first word before brackets. getFNamesInFunction("apply") will return an example of why. – zacdav Sep 13 '16 at 07:49
Hey, can you tell me what is that `x[1]` at the end of sapply? – Sowmya S. Manian Sep 13 '16 at 07:51
it takes the first arg of the split – cccmir Sep 13 '16 at 07:51
you can modify getFNamesInFunction to handle both input types "closure" and "character" by checking typeof() at the start – cccmir Sep 13 '16 at 07:53
1

no, it is part of the sapply. made for getting first arguments after the split – cccmir Sep 13 '16 at 07:54
You mean `typeof(Fun1)`? – Sowmya S. Manian Sep 13 '16 at 07:54
Yes I got that `FUN` is part of sapply. – Sowmya S. Manian Sep 13 '16 at 07:54

Ferdi · Answer 5 · 2016-09-13T07:36:59.247

0

as.list(Fun1)[3]

gives you the part of the function between the curly braces.

{
    sum(x, y)
    mean(x, y)
    c(x, y)
    print(x)
    print(y)
}

Hence

 gsub( ").*$", "", as.list(Fun1)[3])

gives you everything before the first " ) " appears which is presumable the name of the first function.

Taking this as a starting point you should be able to include a loop which gives you the other functions and not the first only the first one.

edited Sep 13 '16 at 07:36

answered Sep 13 '16 at 07:29

Ferdi

540
3
12
23

`gsub` is not working in your answer. I have edited my `grep` part now I am getting the output posted above. Just need to print text before `(` also, if any function is repeating I do not want them to be repeated in the output. – Sowmya S. Manian Sep 13 '16 at 07:34
the gsub is not working. Dont know why. I tried thrice. May be tehre is some problem in the pattern you provided to gsub? – Sowmya S. Manian Sep 13 '16 at 08:04
On my console (RStudio, R 3.3.0) gsub is working. However if I implement some minor changes such as `(` instead of `)` i get the following error **Error in gsub("(.*$", "", as.list(Fun1)[3]) : invalid regular expression '(.*$', reason 'Missing ')''** – Ferdi Sep 13 '16 at 08:08

How to get the list of in-built functions used within a function

5 Answers5

Linked