1. ConceptClang: An Implementation of C++ Concepts in Clang Larisse Voufo, Marcin Zalewski, and Andrew Lumsdaine Open Systems Lab, Indiana University

2. Designing Concepts in C++  Concepts are the basis of generic programming  C++ does not have concepts language feature  Generic programming uses templates  Concepts were proposed but not accepted for C++11  Insufficient implementation experience  ConceptGCC was the only prototype available

3. ConceptClang Goals:  An Infrastructure for Implementing Concepts:  In Clang  Extensible and easily accessible  Independent from any “Concepts” proposal.  “Texas”, “Indiana”, Other?  Adaptable to any proposal.  An implementation based on pre-Frankfurt standard draft.

4. Clang:  What:  LLVM Front-end for the C family of Languages  Why:  Carefully designed coding guidelines.  Modern C++ implementation technology  Highly structured code  Easily understandable  Modular—Library-based approach  License allows extension and experimentation

5. Templates: Example  Template Definition:  Template Use:  traverse a range and accumulate its elements  Need: an iterator, a binary operation template T accumulate(InputIterator first, InputIterator last, T init, BinaryFunction bin_op) { for (; first != last; ++first) init = bin_op(init, *first); return init; } vector v; int i = accumulate(v.begin(), v.end(), 0, plus ());

6. Templates: Mechanism Template Definition: Template Use: Specialization: Instantiation: template <typename InputIterator, typename T, typename BinaryFunction> T accumulate(…) { … } vector v; int i = accumulate ::iterator, int, plus > (v.begin(), v.end(), 0, plus ()); int accumulate(vector ::iter ator first, vector ::iterator last, int init, plus bin_op); int accumulate (vector ::iterator first, vector ::iterator last, int init, plus bin_op) { … }

7. Concepts in C++: Explicit Support  Constrained Templates:  Concept Definitions:  Concept Models template requires (InputIterator, BinaryFunction ) T accumulate(I first, I last, T init, BinOp bin_op) { for (; first != last; ++first) init = bin_op(init, *first); return init; } concept InputIterator { typename value_type; T operator++(T); } concept BinaryFunction { … } concept_map InputIterator ::iterator> { typedef int value_type; T operator++(T t) { … } } concept_map BinaryFunction >{ … }

8. Constrained Template Definition: Constrained Template Use: vector v; int i = accumulate ::iterator, int, plus > (v.begin(), v.end(), 0, plus ()); Constrained Templates: Mechanism Specialization: Instantiation: template <typename I, typename T, typename BinOp> requires (InputIterator, BinaryFunction ) T accumulate(…) { … } int accumulate(vector ::iter ator first, vector ::iterator last, int init, plus bin_op); int accumulate (vector ::iterator first, vector ::iterator last, int init, plus bin_op) { … }

9. Templates: From Unconstrained to Constrained  Poor error detection and diagnosis:  Point to internals of library  Lengthy, hard-to-understand  WORSE: Semantic errors are not detected  Language “tricks”:  too complex, error-prone, and limited  NEED: Separate type- checking!  Errors detected at source  Diagnoses indicate exact source  Without leaking implementation details  Clang pretty-prints  Separate type-checking  We know who to blame!

10. Templates: Problem – Example 1  Template Use:  Compiler error: vector v; int i = accumulate(v.begin(), v.end(), 0, plus ()); Larisse-Voufos-MacBook-Pro:Experiments annlarysm$ g++ accumulate.cpp -o accumulate /usr/include/c++/4.2.1/bits/stl_numeric.h: In function ‘_Tp std::accumulate(_InputIterator, _InputIterator, _Tp, _BinaryOperation) [with _InputIterator = __gnu_cxx::__normal_iterator > >, _Tp = int, _BinaryOperation = std::plus ]’: accumulate.cpp:23: instantiated from here /usr/include/c++/4.2.1/bits/stl_numeric.h:115: error: invalid conversion from ‘void*’ to ‘int’ /usr/include/c++/4.2.1/bits/stl_numeric.h:115: error: initializing argument 2 of ‘_Tp std::plus ::operator()(const _Tp&, const _Tp&) const [with _Tp = int]’ Larisse-Voufos-MacBook-Pro:Experiments annlarysm$ ~/llvm.test/llvm/Debug+Asserts/bin/clang++ accumulate.cpp -o accumulate accumulate.cpp:40:10: error: no matching function for call to 'accumulate' int i = accumulate(v.begin(), v.end(), 0, plus ()); ^~~~~~~~~~ accumulate.cpp:21:3: note: candidate template ignored: constraints check failure [with I = __gnu_cxx::__normal_iterator<void **, std::vector > >, T = int, BinOp = std::plus ] T accumulate(I first, I last, T init, BinOp bin_op) { ^ accumulate.cpp:20:24: note: Concept map requirement not met. requires (InputIterator, BinaryFunction ) ^ accumulate.cpp:20:1: note: Constraints Check Failed: accumulate. requires (InputIterator, BinaryFunction ) ^ 1 error generated. Templates: Solution – Example 1

11. Templates: Problem – Example 2  Template Use:  Compiler error: vector v; sort(v.begin(), v.end(), not_equal_to ()); (None !?) Larisse-Voufos-MacBook-Pro:Experiments annlarysm$ ~/llvm.test/llvm/Debug+Asserts/bin/clang++ accumulate.cpp -o accumulate accumulate.cpp:44:2: error: no matching function for call to 'sort' sort(v.begin(), v.end(), not_equal_to ()); ^~~~ accumulate.cpp:34:6: note: candidate template ignored: constraints check failure [with I = __gnu_cxx::__normal_iterator<int *, std::vector > >, BinOp = std::not_equal_to ] void sort(I first, I last, BinOp comp) { ^ accumulate.cpp:33:31: note: Concept map requirement not met. requires (RandomAccessIterator, StrictWeakOrdering ) ^ accumulate.cpp:33:1: note: Constraints Check Failed: sort. requires (RandomAccessIterator, StrictWeakOrdering ) ^ 1 error generated. Templates: Solution – Example 2

12. Concepts (in C++): Essential Elements  Concept Definitions  Concept refinements  Associated declarations  Concept Modeling  Concept models  Implementations  Generic Algorithm Definition:  Constrained templates  Constrained environments  Generic Algorithm Use:  Type-checking, extended  Constraint-check  Gathers models for constraints  Models for constraints  Stored with specialization

13. Implementation Considerations: General  Concept Definitions  Scoping checks  Lookup in refinements and associated requirements  Concept Modeling  Scoping checks  Check: model vs. concept  Lookup in concept  Generic Algorithm Definition:  Check: constraints validity  Check: body vs. constraints  Lookup in constraints  Generic Algorithm Use:  Constraint-check  Gather models for constraints  Store models for constraints  with Specialization – How?

14. Implementation Considerations: Across Different Proposals  Concept Definitions  Non-dependence checks  Lookup in refinements and associated requirements  Concept Modeling  Non-dependence checks  Check: model vs. concept  Lookup in concept  Generic Algorithm Definition:  Check: constraints validity  Check: body vs. constraints  Lookup in constraints  Generic Algorithm Use:  Constraint-check  Gather models for constraints  Store models for constraints  With specialization – How?  Instantiation

15. ConceptClang Implementation  Concept Definitions  All Declarations in ConceptDecl class  Name lookup, modified.  Concept Modeling  All Declarations in ConceptMapDecl class  Check: model vs. concept  Concept map generation procedure  Name lookup, modified  Generic Algorithm Definition:  Check: constraints validity  Concept map archetypes: represent constraints  Check: body vs. constraints  Name Lookup, modified  Generic Algorithm Use:  Constraint-check procedure  Returns models for constraints  Store models for constraints  In structure for specialization.  Instantiation  Rebuild declaration references

16. ConceptClang Implementation  Concept Definitions  All Declarations in ConceptDecl class  Name Lookup, modified.  Concept Modeling  All Declarations in ConceptMapDecl class  Check: model vs. concept  Concept map generation procedure  Name Lookup, modified  Generic Algorithm Definition:  Check: constraints validity  Concept map archetypes: represent constraints  Check: body vs. constraints  Name Lookup, modified  Generic Algorithm Use:  Constraint-check procedure  Returns models for constraints  Store models for constraints  In structure for specialization.  Instantiation  Rebuild declaration references

17. ConceptClang Implementation: Modified Lookup  Scope flags: control lookup  e.g. DeclScope  parsing a context with multiple declarations  New scope flags:  ConceptDefnScope  ConceptMapScope  RestrictedScope  Restricted- InstantiationScope

18. ConceptClang Implementation  Concept Definitions  All Declarations in ConceptDecl class  Name Lookup, modified.  Concept Modeling  All Declarations in ConceptMapDecl class  Check: model vs. concept  Concept map generation procedure  Name Lookup, modified  Generic Algorithm Definition:  Check: constraints validity  Concept map archetypes: represent constraints  Check: body vs. constraints  Name Lookup, modified  Generic Algorithm Use:  Constraint-check procedure  Returns models for constraints  Store models for constraints  In structure for specialization.  Instantiation  Rebuild declaration references

19. Constraints Check Procedure Constrained Template Definition: Constrained Template Use: Specialization: Maps for Constraints:  Found or generated template <typename I, typename T, typename BinOp> requires (InputIterator, BinaryFunction ) T accumulate(…) { … } vector v; int i = accumulate ::iterator, int, plus > (…); int accumulate(vector ::iter ator first, vector ::iterator last, int init, plus bin_op); InputIterator :: iterator>, BinaryFunction >

20. Concept Map Generation: Satisfying Concept Refinements Concept Definition: Parsed Model Definition: Final Model Implementation: Refinement maps: concept ForwardIterator : InputIterator, OutputIterator { … } concept_map ForwardIterator ::iterator>{ … } InputIterator ::iterator>, OutputIterator ::iterator> concept_map ForwardIterator ::iterator>{ … }

21. Concept Map Template Generation: Satisfying Concept Refinements Concept Definition: Parsed Model Definition: Final Model Implementation: Refinement maps: concept ForwardIterator : InputIterator, OutputIterator { … } template requires (InputIterator, OutputIterator ) concept_map ForwardIterator { … } InputIterator, OutputIterator concept_map ForwardIterator ::iterator>{ … }

22. ConceptClang Implementation: References to Associated Declarations  Concept Definitions  All Declarations in ConceptDecl class  Name Lookup, modified.  Concept Modeling  All Declarations in ConceptMapDecl class  Check: model vs. concept  Concept map generation procedure  Name Lookup, modified  Generic Algorithm Definition:  Check: constraints validity  Concept map archetypes: represent constraints  Check: body vs. constraints  Name Lookup, modified  Generic Algorithm Use:  Constraint-check procedure  Returns models for constraints  Store models for constraints  In structure for specialization.  Instantiation  Rebuild declaration references

23. Template Definition: PARSING ConceptClang Implementation: References to Associated Declarations template requires(C,…) void func(T a,…) { … foo(…); … } Template Specialization: INSTANTIATION void func(int a,…); concept_map C { … foo(…); … } … concept_map C { … foo(…); … } … void func(int a,…) { … foo(…); … }

24. ConceptClang Implementation: References to Constrained Templates  Similar to concept map templates generation  Constraints of calling context == template constraints  Parsing + Rebuilding call expression.

25. Template Definitions: Temporary Template Specialization: PARSING ConceptClang Implementation: References to Constrained Templates template requires(CD,…) void func(T a,…) { … oth_func(a,…); … } Template Specializations: INSTANTIATION void func(int a,…); void func(int a,…) { … oth_func(a,…); … } template requires(C,…) void oth_func(T a,…); void oth_func(int a,…); concept_map C ;… concept_map CD ;… concept_map C ;…

26. ConceptClang Implementation  Concept Definitions  All Declarations in ConceptDecl class  Name Lookup, modified.  Concept Modeling  All Declarations in ConceptMapDecl class  Check: model vs. concept  Concept map generation procedure  Name Lookup, modified  Generic Algorithm Definition:  Check: constraints validity  Concept map archetypes: represent constraints  Check: body vs. constraints  Name Lookup, modified  Generic Algorithm Use:  Constraint-check procedure  Returns models for constraints  Store models for constraints  In structure for specialization.  Instantiation  Rebuild declaration references  Reusability and automation  Clang implementation is reused: Type substitution  Type deduction  Parsing mechanism  Scoping  Unique identification

27. Essential Data Structures ConceptDecl Concept Parameters ConceptMapDecl Template Parameters ≠ 0, for concept map templates TemplateDecl Template Parameters DeclContextFoldingSetNode Scope: DeclScope | ConceptDeclScope | RestrictedScope Scope: DeclScope | ConceptMapScope | RestrictedScope NamedDecl Name Decl …

28. ConceptClang Implementation  Concept Definitions  All Declarations in ConceptDecl class  Name Lookup, modified.  Concept Modeling  All Declarations in ConceptMapDecl class  Check: model vs. concept  Concept map generation procedure  Name Lookup, modified  Generic Algorithm Definition:  Check: constraints validity  Concept map archetypes: represent constraints  Check: body vs. constraints  Name Lookup, modified  Generic Algorithm Use:  Constraint-check procedure  Returns models for constraints  Store models for constraints  In structure for specialization.  Instantiation  Rebuild declaration references

29. Concept-based overloading  Function Overloading:  Partial order on functions  Select most specialized function  Concept-based Overloading:  Constraints resolve ambiguities  Select most constrained as well  Question: Given functions A and B, when:  A is more constrained than B, and  B is more specialized than A  Select which one? //#1 template FI min_element(FI first, FI last); //#2 template T* min_element(T* first, T* last); //Instantiation chooses #2 int *p1, *p2; int* p = min_element(p1, p2); //#1 template FI min_element(FI first, FI last); //#2 template T* min_element(T* first, T* last); //Instantiation chooses #2 int *p1, *p2; int* p = min_element(p1, p2); //#1 template FI min_element(FI first, FI last); //#2 template requires ForwardIterator FI min_element(FI first, FI last); //#3 template requires RandomAccessIterator RI min_element(RI first, RI last); concept_map ForwardIterator ; concept_map RandomAccessIterator ; //Instantiation chooses #3 int *p1, *p2; int* p = min_element(p1, p2); //#1 template FI min_element(FI first, FI last); //#2 template requires ForwardIterator FI min_element(FI first, FI last); //#3 template requires RandomAccessIterator RI min_element(RI first, RI last); concept_map ForwardIterator ; concept_map RandomAccessIterator ; //Instantiation chooses #3 int *p1, *p2; int* p = min_element(p1, p2); //#B template T* min_element(T* first, T* last); //#A template requires ForwardIterator FI min_element(FI first, FI last); concept_map ForwardIterator ; //Instantiation chooses ??? int *p1, *p2; int* p = min_element(p1, p2); //#B template T* min_element(T* first, T* last); //#A template requires ForwardIterator FI min_element(FI first, FI last); concept_map ForwardIterator ; //Instantiation chooses ??? int *p1, *p2; int* p = min_element(p1, p2);

30. Concept-based overloading  Question: Given functions A and B, when:  A is more constrained than B, and  B is more specialized than A  Select which one?  Answer:  Pre-Frankfurt C++: B  ConceptClang:A  Right answer?Open question! //#B template T* min_element(T* first, T* last); //#A template requires ForwardIterator FI min_element(FI first, FI last); concept_map ForwardIterator ; //Instantiation chooses ??? int *p1, *p2; int* p = min_element(p1, p2);

31. Practical Example: Mini-BGL template requires (VertexListGraph, IncidenceGraph, ReadWriteMap, SameType ::key, Graph ::vertex>, Color ::value>, BFSVisitor ) void breadth_first_search(const G& g, vertex s, C c, Vis vis) { pair iter_pair = vertices(g); for(vertex_iter iter = iter_pair.first, iter_end = iter_pair.second; iter != iter_end; ++iter) { vertex u = *iter; initialize_vertex(vis, u, g); set(c, u, white()); } std::queue Q; graph_search(g, s, vis, c, Q); } template requires (VertexListGraph, IncidenceGraph, ReadWriteMap, SameType ::key, Graph ::vertex>, Color ::value>, Visitor, Bag ) void graph_search(const G& g, vertex s, Vis vis, C c, Qtype& Q);

32. Thank You! Questions? http://www.generic-programming.org/software/ConceptClang/ template requires (VertexListGraph, IncidenceGraph, ReadWriteMap, SameType ::key, Graph ::vertex>, Color ::value>, BFSVisitor ) void breadth_first_search(const G& g, vertex s, C c, Vis vis) { pair iter_pair = vertices(g); for(vertex_iter iter = iter_pair.first, iter_end = iter_pair.second; iter != iter_end; ++iter) { vertex u = *iter; initialize_vertex(vis, u, g); set(c, u, white()); } std::queue Q; graph_search(g, s, vis, c, Q); }