Re: With Concepts, it seems a truly heterogeneous container is almost there, but...

David Abrahams wrote:


Thanks for the reference. I already had G on the reading list, but I
hadn't gotten around to it yet. Very interesting work. I find it
tantalising that G achieves full separate compilation, although it
sacrifices some template flexibility and performance in the process.
But it seems we wont see any thing like this in C++ any time soon.
Section 4.1 of the OOPSLA'06 paper "Concepts: Linguistic Support for
Generic Programming in C++" by Gregor et al, compares the chosen
approach for C++ with G and argues for a inclusion model which
(unfortunately) prevents separate compilation:

"The G language shares syntactic constructs with our design for C++.
However, G differs in that it provides separate compilation and
therefore implements a weaker form of concept-based overloading than we
propose for C++ concepts. Concept-based overloading in G is resolved
exclusively based on the lexical information available prior to
template instantiation, whereas we postpone part of the overload
resolution until after instantiation, when more information is
available. This more powerful facility for dispatching prevents the
separate compilation of template definitions, and also prevents
completely separate typechecking, as overload ambiguities may occur
during instantiation. [...] Overall, the inclusion model of templates
is the best match for C++ at this time, although we plan to further
explore the interaction between specialization and separate
compilation."


I've actually just finished that book (well, when do you really finish
a book like that :-). Great stuff. Here's my attempt to apply type
erasure (section 9.7) to the OP's original example:

   // The auto concept

   auto concept Textable <typename T> {
     void T::text (const std::string&);
   };

   // Example classes --- still no inheritance

   class Button {
   public: void text (const std::string&);
   };

   class Control {
   public: void text (const std::string&);
   };

   // Concept adaptors
   // Could this part be automated by the language?

   namespace textable {

     class Base {
       virtual ~Base () {}
       virtual void text (const std::string&) = 0;
     };

     template <Textable T>
     class Adaptor : public Base {
       std::shared_ptr <T> m_obj;
     public:
       Adaptor (T* obj) : m_obj (obj) {}
       virtual void text (const std::string& s) {
         m_obj->text (s); // Delegate.
       }
     };

     class Proxy {
       std::auto_ptr <Base> m_obj;
     public:
       Proxy () {}
       template <class T>
       Proxy (T* obj)
         : m_obj (new Adaptor <T> (obj)) {}
       Base* operator -> () {return m_obj.get ();}
     };
   }
   // Demonstrate use.

   int main () {
     std::vector <textable::Proxy> v;
     v.push_back (new Button);
     v.push_back (new Control);
     for (textable::Proxy& t : v)
       t->text ("Isn't this cool?");
     return 0;
   }

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]