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.
 
     
     
    