
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   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 will disappear once we can depend on R 2.12.0 or greater

        
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.


Speed

    o   rework lhs use of RObject::slot so that it uses R_do_slot_assign 
        instead of an R callback
    	
