@@ -69,7 +69,7 @@ void init_03()
  */
 
 /// @private
-bool func(int i, int j) { return i < j; };
+bool func(int i, int j) { return i < j; }
 
 /// @private
 struct _ {
 
@@ -72,42 +72,42 @@ void init_20()
 */
 
 /**
- @defgroup req20 Requires clause and expression
+ @defgroup req20 'Requires' clause and expression
  @{
 */
 
 // Using 'requires':
 // https://en.cppreference.com/w/cpp/keyword/requires
 
-template <typename T> requires is_integral_v<T> T constexpr requires_demo(T a) { return a + 1; };
+template <typename T> requires is_integral_v<T> T constexpr requires_demo(T a) { return a + 1; }
 
 static_assert(requires_demo(1) == 2);
 
 /**
   requires-clause can be after function declaration and supports template overloading
  */
 
-template <typename T> auto constexpr requires_demo(T && a) requires is_same_v<T, double> { return 2; };
+template <typename T> auto constexpr requires_demo(T && a) requires is_same_v<T, double> { return 2; }
 static_assert(requires_demo(0.1) == 2);
 
 // Annotated example of complex requirement
 template <class T>
 requires // requires-clause
 is_signed_v<T> || is_unsigned_v<T> && ! is_void_v<void> // constraint expression
-void complex_requirement_demo() { };
+void complex_requirement_demo() { }
 
 /// Annotated example of requires-expression
 
 template < class T >
 requires  // requires-clause
 requires() // requires-expression
 { true;} // unevaluated requirements sequence
-void requires_expression_demo() { };
+void requires_expression_demo() { }
 
-template <class T> requires requires(T a) { a / 0; } auto constexpr what(T a) { return 1; };
+template <class T> requires requires(T a) { a / 0; } auto constexpr what(T a) { return 1; }
 static_assert(what(1) == 1);
 
-template <class T> requires requires(T a) { a[0]; } auto constexpr what(T a) { return 2; };
+template <class T> requires requires(T a) { a[0]; } auto constexpr what(T a) { return 2; }
 static_assert(what("2") == 2);
 
 /// @}
@@ -116,15 +116,15 @@ static_assert(what("2") == 2);
   a concept can be defined as function, but not only
  */
 
-template <typename T> concept bool integral_ct() { return is_integral_v<T>; };
+template <typename T> concept bool integral_ct() { return is_integral_v<T>; }
 
-template <integral_ct T> constexpr T _inc3(T a) { return a + 1; };
+template <integral_ct T> constexpr T _inc3(T a) { return a + 1; }
 
 static_assert(_inc3(1) == 2);
 
 // concept can replace type
 
-template <integral_ct T> constexpr T _inc1(T a) { return a + 1; };
+template <integral_ct T> constexpr T _inc1(T a) { return a + 1; }
 
 static_assert(_inc1<int>(1) == 2);
 
@@ -155,7 +155,7 @@ template <class T> concept integral = is_integral_v<T>;
 
 template <class T> concept integral_req_ct = requires (T a) { is_integral_v<T>; };
 
-template <integral_req_ct T> constexpr T _inc2(T a) { return a + 1; };
+template <integral_req_ct T> constexpr T _inc2(T a) { return a + 1; }
 
 static_assert(_inc2(1) == 2);
 
@@ -165,9 +165,9 @@ static_assert(_inc2(1) == 2);
 
 template <typename T> concept bool integral_func_req_ct()
 	requires requires () { is_integral_v<T>; }
-	{ return true; };
+	{ return true; }
 
-template <integral_func_req_ct T> constexpr T _inc4(T a) { return a + 1; };
+template <integral_func_req_ct T> constexpr T _inc4(T a) { return a + 1; }
 
 static_assert(_inc4(1) == 2);
 
 
@@ -1,7 +1,7 @@
 all: 20 17 14 11 03
 CXXFLAGS+=-Wall -Wno-unused
 CXXFLAGS+=-Wextra -Wno-missing-field-initializers
-#CXXFLAGS+=-Wpedantic
+CXXFLAGS+=-Wpedantic
 CXXFLAGS+=-Dgcc_extension
 CXXFLAGS+=-include features.cpp