Reference Classes, tab completion and forced method definition
r, r-s4, reference-class
Solution
I wonder what your objective is? Function names showing up with tab completion? Then it's worth a post to the R-devel mailing list with a feature request. The original scenario is more elegantly handled with `usingMethods` as documented on `?setRefClass`. A continued hack might be
initialize = function(...) {
methods <- getRefClass(class(.self))$methods()
eval(parse(text=paste0(".self$", methods)))
callSuper(...)
}
Tab completions can be customized via `.DollarNames` in the `utils` package, so
.DollarNames.TEST <- function(x, pattern)
grep(pattern, getRefClass(class(x))$methods(), value=TRUE)
Maybe an S3 method could be written at the base of your class hierarchy for this?
Problem
I am currently writing a package using reference classes. I have come across an issue which from reading various sources: Method initialisation in R reference classes Can't reliably use RefClass methods in Snowfall I gather is caused because reference methods are not all copied to every object in the class rather they are copied when first accessed. https://stat.ethz.ch/pipermail/r-devel/2011-June/061261.html As an example define: ``` test <- setRefClass("TEST", fields = list( a = "numeric"), methods = list( addone = function(){ a <<- a+1 }, initialize = function(){ a <<- 1 } ) ) example <- test$new() ``` So example is a new object of class `TEST`. Typing `example$` and tabbing in the console gives ``` > example$ # example$.->a example$.refClassDef example$.self # example$a example$initialize ``` so the method `addone` is not presented as an option. It is available to call however: ``` example$addone() ``` Now tabbing again reveals ``` # > # > example # Reference class object of class "TEST" # Field "a": # [1] 2 # > example$ # example$.->a example$.refClassDef example$.self # example$a example$addone example$field # example$initialize example$show ``` so now `addone` and `field` and `show` are presented as options. Martin Morgan advises to force definition of the methods in one of the above links. This works well ``` test <- setRefClass("TEST", fields = list( a = "numeric"), methods = list( addone = function(){ a <<- a+1 }, initialize = function(){ a <<- 1 .self$addone #force definition } ) ) example <- test$new() ``` so now tabbing gives: ``` # > example$ # example$.->a example$.refClassDef example$.self # example$a example$addone example$initialize ``` Some of my classes have over 30 methods so I would like to do this as succintly as possible. I have defined: ``` test <- setRefClass("TEST", fields = list( a = "numeric"), methods = list( addone = function(){ a <<- a+1 }, initialize = function(){ a <<- 1 eval(parse(text=paste0('.self$',ls(test$def@refMethods)))) } ) ) example <- test$new() ``` tabbing now gives: ``` # > example$ # example$.->a example$.refClassDef example$.self # example$a example$addone example$callSuper # example$copy example$export example$field # example$getClass example$getRefClass example$import # example$initFields example$initialize example$show # example$trace example$untrace ``` Whilst this works it feels a bit clumsy. Also `test$def@refMethods` is used rather then `getRefClass("TEST")$def@refMethods` so that feels a bit wrong. Has anyone dealt with this issue before. Is there a better way to approach a solution? Thanks for any advice and apologies if the question is overly drawn out.