
Documentation

    o   Bring "Rcpp ? NumericVector" into life. The hook is in place, we just need
        to come up with some way to generate useful documentation for it: general
        description of the class, related unit test cases, etc ...
                
    o   Rework ?Rcpp which is mainly old api centric

    o   Add a vignette about Rcpp sugar [in progress]
    
    o   Add a vignette about the api

API

    o   Rcpp::Factor and Rcpp::Ordered
    
    o	const operators, as requested on Rcpp-devel:
    	http://permalink.gmane.org/gmane.comp.lang.r.rcpp/494

Modules 

    o   Exposing constructors. For now we can only construct internal objects 
        with the default constructor of the target class. Maybe we can provide
        some R level dispatch. Maybe look at ?selectMethod
        
    o   Class inheritance. If we have Foo and Bar : public Foo, and we expose
        both Foo and Bar to R, R level class Bar should enjoy methods of Foo
        and the S4 inheritance should reflect the C++ level inheritance
                
    o   Method overloading: methods are currently stored in a map<string,.>
        so there can only be one method for a given name, which defeats C++
        overloading. Maybe we can do better than that. This might also need 
        R level dispatch (?selectMethod)
        

R 2.12.0

    o   Remove the C++ObjectS3 class as it is no longer needed:
        http://permalink.gmane.org/gmane.comp.lang.r.devel/24610

    o   Order of classes in POSIXt: this currently is implemented internally
    	with conditional compiling based on the version of R. The conditional
    	compiling must disappear when we can depend on R 2.12.0
        
Syntactic sugar

    o   duplicated, unique, count, sum, sqrt, log, log10, ln
    
    o	operator% 
    
    o	operator/ needs to handle the case of division by 0

    o   min, max with specialization of the binary operators, so that we can do 
        things like this lazily: 
        
        min( x ) < 4
    
    o   matrix functions : apply
    
    o   for character vectors: nchar, grepl, sub, gsub
    
    o   Compound operators: ++,--,+=, -=, ...
        
    o	lazy evaluation might not be the best thing for the sugar 
    	implementation of outer. For example : 
    	
    	outer( x + y, z , plus<double>() )
    	
    	has to evaluate x[i] + y[i] as many times as the length
    	of z. perhaps a better implementation would be to 
    	first force the evaluation of x + y.
    
Testing

    o   we need to update the doRUnit.R file and replace : 
        
          ##  stop() if there are any failures i.e. FALSE to unit test.
          ## This will cause R CMD check to return error and stop
          err <- getErrors(tests)
          if( (err$nFail + err$nErr) > 0) {
              stop( sprintf( "unit test problems: %d failures, %d errors", 
                             err$nFail, err$nErr) )
          } else{
              success <- err$nTestFunc - err$nFail - err$nErr - err$nDeactivated
              cat( sprintf( "%d / %d\n", success, err$nTestFunc ) )
          }
       
        by something that extract information from "err". This is needed
        because on win builder or cran checks, we only ever get the last 13
        lines of output. So we need to make the best use of these 13 lines
        
   o    Testing has become slow. That would be good to find ways to make it
        faster such as combine multiple functions in a single cxxfunction
        call or alternatively make another package (perhaps internal to this
        one that would contain test cases) [in progress]
                
   o    Maybe make test function 'tier one' and 'tier two' and run only the
        first tier if an (environment ?) variable has been set?

