Reference Classes, tab completion and forced method definition

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.

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?