{"id":5171,"date":"2017-02-08T21:35:16","date_gmt":"2017-02-08T21:35:16","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/concepts-lite\/"},"modified":"2023-06-26T12:24:07","modified_gmt":"2023-06-26T12:24:07","slug":"concepts-lite","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/concepts-lite\/","title":{"rendered":"Concepts"},"content":{"rendered":"

We stay in the year 2020. With high probability, we will get concepts. Of course, waterproof statements about the future are challenging, but the statement is from Bjarne Stroustrup (Meeting C++ 2016<\/a> at Berlin).<\/p>\n

<\/p>\n

The classical concepts<\/h2>\n

The key idea of generic programming with templates is to define functions and classes that can be used with different types. But it will often happen that you instantiate a template with the wrong type. The result may be a cryptic error message that is many pages long. Sadly to say, templates in C++ are known for this. Therefore, classical concepts were planned as one of the great features of C++11. They should allow you to specify constraints for templates that the compiler can verify. Thanks to their complexity, they were removed in July 2009 from the standard:  “The C++0x concept design evolved into a monster of complexity.” (Bjarne Stroustrup)<\/p>\n<\/p>\n

Concepts<\/h2>\n

With C++20 we will get concepts. Although concepts are in the first implementations of simplified classical concepts, they have much to offer.<\/p>\n

They<\/p>\n

    \n
  1. empower the programmer to express their requirements as part of the interface directly.<\/li>\n
  2. support the overloading of functions and the specialization of class templates based on the requirements of the template parameters.<\/li>\n
  3. produce drastically improved error messages by comparing the requirements of the template parameter with the applied template arguments.<\/li>\n
  4. can be used as placeholders for generic programming.<\/li>\n
  5. empower you to define your own concepts.<\/li>\n<\/ol>\n

    Although concepts are sometimes called concepts lite, their functionality is by no means lite and I can not be presented in one post. Therefore, I will postpone points 4 and 5 to later posts. Promised!
    <\/em><\/p>\n

    You will benefit without additional compile-time or runtime time of the program. Concepts are similar to Haskell’s type classes. Concepts will describe semantic categories and not syntactic restrictions. For standard library types, we get library concepts<\/a> such as DefaultConstructible, MoveConstructible, CopyConstructible, MoveAssignable, CopyAssignable<\/span>,  or Destructible<\/span>. For the containers, we get concepts such as ReversibleContainer, AllocatorAwareContainer, SequenceContainer, ContinousContainer, AssociativeContainer<\/span>, or UnorderedAssociativeContainer<\/span>. You can read the about concepts and their constraints here: cppreference.com<\/a>.<\/p>\n

    Before I present concepts, let me have a view of Haskell’s type classes.<\/p>\n

    Type classes in Haskell<\/h3>\n

    Type classes are interfaces for similar types. If a type is a member of a type class, it has to have specific properties. Type classes play a similar role in generic programming as interfaces play in object-oriented programming. Here you can see a part of Haskell’s type classes hierarchy.<\/p>\n

    \"typeclass\"<\/p>\n

    What is unique for a type if it is a member of a type class Eq<\/span>? Eq<\/span> stands for equality and requires from its members:<\/p>\n

     <\/p>\n

    \n
    class<\/span> Eq<\/span> a where<\/span>\r\n    (==) ::<\/span> a -><\/span> a -><\/span> Bool<\/span>\r\n    (\/=) ::<\/span> a -><\/span> a -><\/span> Bool<\/span>\r\n    a == b =<\/span> not (a \/= b)\r\n    a \/= b =<\/span> not (a == b)\r\n<\/pre>\n<\/div>\n
    Eq<\/span> requires that its types support the functions equality (==<\/span>) and inequality (\/=)<\/span>. The expression a -> a -> Bool<\/span> stands for the function’s signature. The function takes two identical types a<\/span> and returns a Boolean: Bool<\/span>. But for a concrete type, it is sufficient to implement equality or inequality because equality will be mapped to inequality and vice versa. The default implementations of both functions are provided in the two last lines.<\/p>\n
    By the following code snipped, the built-in type Bool<\/span> becomes an instance of the type class Eq<\/span>.<\/p>\n
    \n
    instance<\/span> Eq<\/span> Bool<\/span> where<\/span>\r\n    True<\/span> == True<\/span> =<\/span> True<\/span>\r\n    False<\/span> == False<\/span> =<\/span> True<\/span>\r\n    _<\/span> == _<\/span> =<\/span> False<\/span>\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Haskell’s type classes build a hierarchy. The type class  Ord<\/span> is a subclass of the type class Eq.<\/span> Therefore, instances of the type class Ord<\/span> have to be members of the type class Eq<\/span> and have, in addition, support the comparison operators.<\/p>\n
    Haskell can automatically create the necessary functions of some class types. Therefore, I can compare the values Morning <\/span>and Afternoon <\/span>of the data type day for equality and output them. I have only to derive Day from the type class Eq <\/span>and Show<\/span>.<\/p>\n
    \n
    data<\/span> Day<\/span>=<\/span> Morning<\/span> | Afternoon<\/span>\r\n     deriving<\/span> (Eq<\/span>,Show<\/span>)\r\n<\/pre>\n<\/div>\n
    I can directly test my data type Day <\/span>in the interactive Haskell Shell. The formal name for the interactive Shell is REPL. Many programming languages, such as Python or Perl, have a REPL. REPL stands for R<\/strong>ead E<\/strong>valuate P<\/strong>rint L<\/strong>oop.<\/strong><\/p>\n
     \"day\"<\/p>\n
    Type classes in Haskell have a lot more to offer. For example, you can define your own class.<\/p>\n
    Concepts for functions, classes, and members of a class<\/h3>\n
    Concepts are part of the template declaration.<\/p>\n
    Functions<\/h4>\n
    The function template sort<\/span> requires<\/p>\n
    \n
    template<\/span><Sortable Cont>\r\nvoid<\/span> sort(Cont& container){...}\r\n\r\n<\/pre>\n<\/div>\n
    that the container has to be Sortable<\/span>. It is also possible to define the requirement for the template parameters more explicitly:<\/p>\n
     <\/p>\n
    \n
    template<\/span><typename<\/span> Cont>\r\n  requires Sortable<Cont>()\r\nvoid<\/span> sort(Cont& container){...}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Sortable<\/span> has to be a constant expression that is a predicate. That means that the expression must be evaluable at compile time and return a boolean.<\/p>\n
    If you invoke the sort algorithm with a container lst <\/span>that is not sortable, you will have a unique error message from the compiler.<\/p>\n
    \n
    std::list<int<\/span>> lst = {1998,2014,2003,2011};\r\nsort(lst); \/\/ ERROR: lst is no random-access container with <<\/span>\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    You can use concepts for all kinds of templates.<\/p>\n
    Classes<\/h4>\n
    Therefore, you can define a class template MyVector<\/span> that will only accept objects as template arguments:<\/p>\n
    \n
    template<\/span><Object T>\r\nclass<\/span> MyVector<\/span>{};\r\n\r\nMyVector<int<\/span>> v1; \/\/ OK<\/span>\r\nMyVector<int<\/span>&> v2 \/\/ ERROR: int& does not satisfy the constraint Object<\/span>\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Now, the compiler complains that the pointer (int&<\/span>)  is no object. MyClass<\/span> can be further adjusted.<\/p>\n
    Members of a class<\/h4>\n
    \n
    template<\/span><Object T>\r\nclass<\/span> MyVector<\/span>{\r\n  ...\r\n  requires Copyable<T>()\r\n  void<\/span> push_back(const<\/span> T& e);\r\n  ...\r\n};\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Now the method  push_back<\/span>  from MyVector requires that the template argument has to be copyable.<\/span><\/span><\/p>\n
    Extended functionality<\/h3>\n
    A template can have more than one requirement for its template parameters.<\/p>\n
    More than one requirement<\/h4>\n
    \n
    template<\/span> <SequenceContainer S,EqualityComparable<value_type<S>> T>\r\nIterator_type<S> find(S&& seq, const<\/span> T& val){...}\r\n<\/pre>\n<\/div>\n
    The function template find has two requirements. On the one hand, the container has to store its elements in a linear arrangement (SequenceContainer<\/span>); on the other hand, the elements of the container have to be equality comparable: EqualityComparable<value_type<S>><\/span>).<\/p>\n
    Concepts support the overloading of functions.<\/p>\n
    Overloading of functions<\/h4>\n
    \n
    template<\/span><InputIterator I>\r\nvoid<\/span> advance(I& iter, int<\/span> n){...}\r\n\r\ntemplate<\/span><BidirectionalIterator I>\r\nvoid<\/span> advance(I& iter, int<\/span> n){...}\r\n\r\ntemplate<\/span><RandomAccessIterator I>\r\nvoid<\/span> advance(I& iter, int<\/span> n){...}\r\n\r\nstd::list<int<\/span>> lst{1,2,3,4,5,6,7,8,9};\r\nstd::list<int<\/span>>:: iterator i= lst.begin();\r\nstd::advance(i,2);   \/\/ BidirectionalIterator<\/span>\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    The function template advance<\/span> puts its’s iterator iter<\/span> n<\/span> positions further. Different function templates will be applied depending on whether the iterator is a forward, a bi-directional, or a random access iterator. If I use a std::list, the BidirectionalIterator<\/span> will be chosen.<\/p>\n
    Concepts also support the specialization of class templates.<\/p>\n
    The specialization of class templates<\/h4>\n
    \n
    template<\/span><typename<\/span> T>\r\nclass<\/span> MyVector<\/span>{};\r\n\r\ntemplate<\/span><Object T>\r\nclass<\/span> MyVector<\/span>{};\r\n\r\nMyVector<int<\/span>> v1; \/\/ Object T<\/span>\r\nMyVector<int<\/span>&> v2 \/\/ typename T<\/span>\r\n<\/pre>\n<\/div>\n
    Therefore, the compiler maps MyVector<int&> v2<\/span> to the general template in the first line; the compiler maps MyVector<int> v1<\/span> on the contrary to the specialization template<Object T> class MyVector{}.<\/span><\/p>\n
    What’s next?<\/h2>\n
    Haskell has the type class Monad<\/span>.  A known instance is the Maybe Monad<\/span>. Why did I write about that stuff? That is simple. C++17 gets with the data type std::optiona<\/span>l a Monad<\/span> that represents a calculation that can or can not return a result. The details about std::optional<\/span> will follow in the next post<\/a>.   
    <\/span><\/p>\n
     <\/p>\n
     <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
    We stay in the year 2020. With high probability, we will get concepts. Of course, waterproof statements about the future are challenging, but the statement is from Bjarne Stroustrup (Meeting C++ 2016 at Berlin).<\/p>\n","protected":false},"author":21,"featured_media":5169,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[365],"tags":[415,508],"class_list":["post-5171","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-functional","tag-concepts","tag-haskell"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5171","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5171"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5171\/revisions"}],"predecessor-version":[{"id":6890,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5171\/revisions\/6890"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5169"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5171"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5171"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5171"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}