// N4606 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf
#define msg "(206)14.8.2.5 Deducing template arguments from a type [temp.deduct.type]p419.cpp"
// Edited by Dr. Ogawa Kiyoshi. Compile procedure and results record.

#include <iostream>

template<class T> void g(T);
g({1,2,3}); // error: no argument deduced for T

template<class T> void f(T x, T y) { /* ... */ }
struct A { /* ... */ };
struct B : A { /* ... */ };
void g(A a, B b) {
f(a,b); // error: T could be A or B
f(b,a); // error: T could be A or B
f(a,a); // OK: T is A
f(b,b); // OK: T is B
}

template <class T, class U> void f( T (*)( T, U, U ) );
int g1( int, float, float);
char g2( int, float, float);
int g3( int, char, float);
void r() {
f(g1); // OK: T is int and U is float
f(g2); // error: T could be char or int
f(g3); // error: U could be char or float
}

template<class T> void f(const T*) { }
int* p;
void s() {
f(p); // f(const int*)
}

template <class T> struct B { };
template <class T> struct D : public B<T> {};
struct D2 : public B<int> {};
template <class T> void f(B<T>&){}
void t() {
D<int> d;
D2 d2;
f(d); // calls f(B<int>&)
f(d2); // calls f(B<int>&)
}


template<class T1, class... Z> class S; // #1
template<class T1, class... Z> class S<T1, const Z&...> { }; // #2
template<class T1, class T2> class S<T1, const T2&> { }; // #3
S<int, const int&> s; // both #2 and #3 match; #3 is more specialized
template<class T, class... U> struct A { }; // #1
template<class T1, class T2, class... U> struct A<T1, T2*, U...> { }; // #2
template<class T1, class T2> struct A<T1, T2> { }; // #3
template struct A<int, int*>; // selects #2

template <class T> void f(T&&);
template <> void f(int&) { } // #1
template <> void f(int&&) { } // #2
void g(int i) {
f(i); // calls f<int&>(int&), i.e., #1
f(0); // calls f<int>(int&&), i.e., #2
}

template<class T, class... U> void f(T*, U...) { } // #1
template<class T> void f(T) { } // #2
template void f(int*); // selects #1

//X<int> (*)(char[6])
int main() {
  std::cout<< msg << std::endl;
  return EXIT_SUCCESS;
}

i$ ./cppgl17.sh p419
$ clang++ p419.cpp -std=c++17 
p419.cpp:9:1: error: C++ requires a type specifier for all declarations
g({1,2,3}); // error: no argument deduced for T
^
p419.cpp:15:1: error: no matching function for call to 'f'
f(a,b); // error: T could be A or B
^
p419.cpp:11:24: note: candidate template ignored: deduced conflicting types for parameter 'T' ('A' vs. 'B')
template<class T> void f(T x, T y) { /* ... */ }
                       ^
p419.cpp:16:1: error: no matching function for call to 'f'
f(b,a); // error: T could be A or B
^
p419.cpp:11:24: note: candidate template ignored: deduced conflicting types for parameter 'T' ('B' vs. 'A')
template<class T> void f(T x, T y) { /* ... */ }
                       ^
p419.cpp:27:1: error: no matching function for call to 'f'
f(g2); // error: T could be char or int
^
p419.cpp:21:34: note: candidate template ignored: deduced conflicting types for parameter 'T' ('char' vs. 'int')
template <class T, class U> void f( T (*)( T, U, U ) );
                                 ^
p419.cpp:11:24: note: candidate function template not viable: requires 2 arguments, but 1 was provided
template<class T> void f(T x, T y) { /* ... */ }
                       ^
p419.cpp:28:1: error: no matching function for call to 'f'
f(g3); // error: U could be char or float
^
p419.cpp:21:34: note: candidate template ignored: deduced conflicting types for parameter 'U' ('char' vs. 'float')
template <class T, class U> void f( T (*)( T, U, U ) );
                                 ^
p419.cpp:11:24: note: candidate function template not viable: requires 2 arguments, but 1 was provided
template<class T> void f(T x, T y) { /* ... */ }
                       ^
p419.cpp:44:1: error: use of undeclared identifier 'f3'
f3(d); // calls f3(B3<int>&)
^
p419.cpp:45:1: error: use of undeclared identifier 'f3'
f3(d2); // calls f3(B3<int>&)
^
p419.cpp:56:17: error: ambiguous partial specializations of 'A4<int, int *>'
template struct A4<int, int*>; // selects #2
                ^
p419.cpp:54:49: note: partial specialization matches [with T1 = int, T2 = int, U = <>]
template<class T1, class T2, class... U> struct A4<T1, T2*, U...> { }; // #2
                                                ^
p419.cpp:55:37: note: partial specialization matches [with T1 = int, T2 = int *]
template<class T1, class T2> struct A4<T1, T2> { }; // #3
                                    ^
8 errors generated.

$ g++-7 p419.cpp -std=c++17 
p419.cpp:9:2: error: expected constructor, destructor, or type conversion before '(' token
 g({1,2,3}); // error: no argument deduced for T
  ^
p419.cpp:9:10: error: expected unqualified-id before ')' token
 g({1,2,3}); // error: no argument deduced for T
          ^
p419.cpp: In function 'void g(A, B)':
p419.cpp:15:6: error: no matching function for call to 'f(A&, B&)'
 f(a,b); // error: T could be A or B
      ^
p419.cpp:11:24: note: candidate: template<class T> void f(T, T)
 template<class T> void f(T x, T y) { /* ... */ }
                        ^
p419.cpp:11:24: note:   template argument deduction/substitution failed:
p419.cpp:15:6: note:   deduced conflicting types for parameter 'T' ('A' and 'B')
 f(a,b); // error: T could be A or B
      ^
p419.cpp:16:6: error: no matching function for call to 'f(B&, A&)'
 f(b,a); // error: T could be A or B
      ^
p419.cpp:11:24: note: candidate: template<class T> void f(T, T)
 template<class T> void f(T x, T y) { /* ... */ }
                        ^
p419.cpp:11:24: note:   template argument deduction/substitution failed:
p419.cpp:16:6: note:   deduced conflicting types for parameter 'T' ('B' and 'A')
 f(b,a); // error: T could be A or B
      ^
p419.cpp: In function 'void r()':
p419.cpp:27:5: error: no matching function for call to 'f(char (&)(int, float, float))'
 f(g2); // error: T could be char or int
     ^
p419.cpp:11:24: note: candidate: template<class T> void f(T, T)
 template<class T> void f(T x, T y) { /* ... */ }
                        ^
p419.cpp:11:24: note:   template argument deduction/substitution failed:
p419.cpp:27:5: note:   candidate expects 2 arguments, 1 provided
 f(g2); // error: T could be char or int
     ^
p419.cpp:21:34: note: candidate: template<class T, class U> void f(T (*)(T, U, U))
 template <class T, class U> void f( T (*)( T, U, U ) );
                                  ^
p419.cpp:21:34: note:   template argument deduction/substitution failed:
p419.cpp:27:5: note:   deduced conflicting types for parameter 'T' ('char' and 'int')
 f(g2); // error: T could be char or int
     ^
p419.cpp:28:5: error: no matching function for call to 'f(int (&)(int, char, float))'
 f(g3); // error: U could be char or float
     ^
p419.cpp:11:24: note: candidate: template<class T> void f(T, T)
 template<class T> void f(T x, T y) { /* ... */ }
                        ^
p419.cpp:11:24: note:   template argument deduction/substitution failed:
p419.cpp:28:5: note:   candidate expects 2 arguments, 1 provided
 f(g3); // error: U could be char or float
     ^
p419.cpp:21:34: note: candidate: template<class T, class U> void f(T (*)(T, U, U))
 template <class T, class U> void f( T (*)( T, U, U ) );
                                  ^
p419.cpp:21:34: note:   template argument deduction/substitution failed:
p419.cpp:28:5: note:   deduced conflicting types for parameter 'U' ('char' and 'float')
 f(g3); // error: U could be char or float
     ^
p419.cpp: In function 'void t()':
p419.cpp:44:1: error: 'f3' was not declared in this scope
 f3(d); // calls f3(B3<int>&)
 ^~
p419.cpp:44:1: note: suggested alternative: 'f'
 f3(d); // calls f3(B3<int>&)
 ^~
 f
p419.cpp: At global scope:
p419.cpp:56:17: error: ambiguous template instantiation for 'struct A4<int, int*>'
 template struct A4<int, int*>; // selects #2
                 ^~~~~~~~~~~~~
p419.cpp:54:49: note: candidates are: template<class T1, class T2, class ... U> struct A4<T1, T2*, U ...> [with T1 = int; T2 = int; U = {}]
 template<class T1, class T2, class... U> struct A4<T1, T2*, U...> { }; // #2
                                                 ^~~~~~~~~~~~~~~~~
p419.cpp:55:37: note:                 template<class T1, class T2> struct A4<T1, T2> [with T1 = int; T2 = int*]
 template<class T1, class T2> struct A4<T1, T2> { }; // #3
                                     ^~~~~~~~~~
p419.cpp:56:17: error: explicit instantiation of 'struct A4<int, int*>' before definition of template
 template struct A4<int, int*>; // selects #2
                 ^~~~~~~~~~~~~

// N4606 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf
#define msg "(206)14.8.2.5 Deducing template arguments from a type [temp.deduct.type]p419-2.cpp"
// Edited by Dr. Ogawa Kiyoshi. Compile procedure and results record.

#include <iostream>

template<long n> struct A { };
template<typename T> struct C;
template<typename T, T n> struct C<A<n>> {
using Q = T;
};
using R = long;
using R = C<A<2>>::Q; // OK; T was deduced to long from the
// template argument value in the type A<2>

template<typename T> struct S;
template<typename T, T n> struct S<int[n]> {
using Q = T;
};
using V = decltype(sizeof 0);
using V = S<int[42]>::Q; // OK; T was deduced to std::size_t from the type int[42]

template<class T, T i> void f(int (&a)[i]);
int v[10];
void g() {
f(v); // OK: T is std::size_t
}

template<int i> void f1(int a[10][i]);
template<int i> void f2(int a[i][20]);
template<int i> void f3(int (&a)[i][20]);
void g() {
int v[10][20];
f1(v); // OK: i deduced to be 20
f1<20>(v); // OK
f2(v); // error: cannot deduce template-argument i
f2<10>(v); // OK
f3(v); // OK: i deduced to be 10
}

template <int i> class A { /* ... */ };
template <int i> void g(A<i+1>);
template <int i> void f(A<i>, A<i+1>);
void k() {
A<1> a1;
A<2> a2;
g(a1); // error: deduction fails for expression i+1
g<0>(a1); // OK
f(a1, a2); // OK
}

int main() {
  std::cout<< msg << std::endl;
  return EXIT_SUCCESS;
}

$ ./cppgl17.sh p419-2
$ clang++ p419-2.cpp -std=c++17 
p419-2.cpp:37:1: error: no matching function for call to 'f2'
f2(v); // error: cannot deduce template-argument i
^~
p419-2.cpp:31:22: note: candidate template ignored: couldn't infer template argument 'i'
template<int i> void f2(int a[i][20]);
                     ^
p419-2.cpp:48:1: error: no matching function for call to 'g4'
g4(a1); // error: deduction fails for expression i+1
^~
p419-2.cpp:43:23: note: candidate template ignored: couldn't infer template argument 'i'
template <int i> void g4(A4<i+1>);
                      ^
2 errors generated.

$ g++-7 p419-2.cpp -std=c++17 
p419-2.cpp: In function 'void g3()':
p419-2.cpp:37:5: error: no matching function for call to 'f2(int [10][20])'
 f2(v); // error: cannot deduce template-argument i
     ^
p419-2.cpp:31:22: note: candidate: template<int i> void f2(int (*)[20])
 template<int i> void f2(int a[i][20]);
                      ^~
p419-2.cpp:31:22: note:   template argument deduction/substitution failed:
p419-2.cpp:37:5: note:   couldn't deduce template parameter 'i'
 f2(v); // error: cannot deduce template-argument i
     ^
p419-2.cpp: In function 'void k()':
p419-2.cpp:48:6: error: no matching function for call to 'g4(A4<1>&)'
 g4(a1); // error: deduction fails for expression i+1
      ^
p419-2.cpp:43:23: note: candidate: template<int i> void g4(A4<(i + 1)>)
 template <int i> void g4(A4<i+1>);
                       ^~
p419-2.cpp:43:23: note:   template argument deduction/substitution failed:
p419-2.cpp:48:6: note:   couldn't deduce template parameter 'i'
 g4(a1); // error: deduction fails for expression i+1
      ^

// N4606 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf
#define msg "(206)14.8.2.5 Deducing template arguments from a type [temp.deduct.type]p419-2.cpp"
// Edited by Dr. Ogawa Kiyoshi. Compile procedure and results record.

#include <iostream>
template<int i, typename T>
T deduce(typename A<T>::X x, // T is not deduced here
T t, // but T is deduced here
typename B<i>::Y y); // i is not deduced here
A<int> a;
B<77> b;
int x = deduce<77>(a.xm, 62, b.ym);
// T is deduced to be int, a.xm must be convertible to
// A<int>::X
// i is explicitly specified to be 77, b.ym must be convertible
// to B<77>::Y
template<int i> class A { /* ... */ };
template<short s> void f(A<s>);
void k1() {
A<1> a;
f(a); // error: deduction fails for conversion from int to short
f<1>(a); // OK
}
template<const short cs> class B { };
template<short s> void g(B<s>);
void k2() {
B<1> b;
g(b); // OK: cv-qualifiers are ignored on template parameter types
}

template<class T> void f(void(*)(T,int));
template<class T> void foo(T,int);
void g(int,int);
void g(char,int);
void h(int,int,int);
void h(char,int);
int m() {
f(&g); // error: ambiguous
f(&h); // OK: void h(char,int) is a unique match
f(&foo); // error: type deduction fails because foo is a template
}

template <class T> void f(T = 5, T = 7);
void g() {
f(1); // OK: call f<int>(1,7)
f(); // error: cannot deduce T
f<int>(); // OK: call f<int>(5,7)
}

template <template <class T> class X> struct A { };
template <template <class T> class X> void f(A<X>) { }
template<class T> struct B { };
A<B> ab;
f(ab); // calls f(A<B>)

template<class> struct X { };
template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
template<class ... Types> struct Y { };
template<class T, class ... Types> struct Y<T, Types& ...> { };
template<class ... Types> int f(void (*)(Types ...));
void g(int, float);
X<int> x1; // uses primary template
X<int(int, float, double)> x2; // uses partial specialization; ArgTypes contains float, double
X<int(float, int)> x3; // uses primary template
Y<> y1; // use primary template; Types is empty
Y<int&, float&, double&> y2; // uses partial specialization; T is int&, Types contains float, double
Y<int, float, double> y3; // uses primary template; Types contains int, float, double
int fv = f(g); // OK; Types contains int, float


int main() {
  std::cout<< msg << std::endl;
  return EXIT_SUCCESS;
}

$ ./cppgl17.sh p419-3
$ clang++ p419-3.cpp -std=c++17 
p419-3.cpp:8:19: error: expected a qualified name after 'typename'
T deduce(typename A<T>::X x, // T is not deduced here
                  ^
p419-3.cpp:8:19: error: expected a qualified name after 'typename'
p419-3.cpp:8:20: error: expected ')'
T deduce(typename A<T>::X x, // T is not deduced here
                   ^
p419-3.cpp:8:9: note: to match this '('
T deduce(typename A<T>::X x, // T is not deduced here
        ^
p419-3.cpp:11:1: error: no template named 'A'
A<int> a;
^
p419-3.cpp:12:1: error: no template named 'B'
B<77> b;
^
p419-3.cpp:22:1: error: no matching function for call to 'f'
f(a); // error: deduction fails for conversion from int to short
^
p419-3.cpp:19:24: note: candidate template ignored: substitution failure : deduced non-type template argument does not have the same type as
      the corresponding template parameter ('int' vs 'short')
template<short s> void f(A<s>);
                       ^
p419-3.cpp:39:1: error: no matching function for call to 'f'
f(&g); // error: ambiguous
^
p419-3.cpp:19:24: note: candidate template ignored: couldn't infer template argument 's'
template<short s> void f(A<s>);
                       ^
p419-3.cpp:32:24: note: candidate template ignored: couldn't infer template argument 'T'
template<class T> void f(void(*)(T,int));
                       ^
p419-3.cpp:41:1: error: no matching function for call to 'f'
f(&foo); // error: type deduction fails because foo is a template
^
p419-3.cpp:19:24: note: candidate template ignored: couldn't infer template argument 's'
template<short s> void f(A<s>);
                       ^
p419-3.cpp:32:24: note: candidate template ignored: couldn't infer template argument 'T'
template<class T> void f(void(*)(T,int));
                       ^
p419-3.cpp:47:1: error: no matching function for call to 'f'
f(); // error: cannot deduce T
^
p419-3.cpp:44:25: note: candidate template ignored: couldn't infer template argument 'T'
template <class T> void f(T = 5, T = 7);
                        ^
p419-3.cpp:19:24: note: candidate function template not viable: requires 1 argument, but 0 were provided
template<short s> void f(A<s>);
                       ^
p419-3.cpp:32:24: note: candidate function template not viable: requires 1 argument, but 0 were provided
template<class T> void f(void(*)(T,int));
                       ^
p419-3.cpp:51:36: error: template parameter has a different kind in template redeclaration
template <template <class T> class X> struct A { };
                                   ^
p419-3.cpp:18:14: note: previous template declaration is here
template<int i> class A { /* ... */ };
             ^
p419-3.cpp:52:48: error: template argument for non-type template parameter must be an expression
template <template <class T> class X> void f(A<X>) { }
                                               ^
p419-3.cpp:18:14: note: template parameter is declared here
template<int i> class A { /* ... */ };
             ^
p419-3.cpp:53:16: error: template parameter has a different kind in template redeclaration
template<class T> struct B { };
               ^
p419-3.cpp:25:22: note: previous template declaration is here
template<const short cs> class B { };
                     ^
p419-3.cpp:54:3: error: template argument for non-type template parameter must be an expression
A<B> ab;
  ^
p419-3.cpp:18:14: note: template parameter is declared here
template<int i> class A { /* ... */ };
             ^
p419-3.cpp:55:1: error: unknown type name 'f'
f(ab); // calls f(A<B>)
^
14 errors generated.

$ g++-7 p419-3.cpp -std=c++17 
p419-3.cpp:8:19: error: expected nested-name-specifier before 'A'
 T deduce(typename A<T>::X x, // T is not deduced here
                   ^
p419-3.cpp:8:19: error: expected '(' before 'A'
p419-3.cpp:9:3: error: expected primary-expression before 't'
 T t, // but T is deduced here
   ^
p419-3.cpp:10:10: error: expected nested-name-specifier before 'B'
 typename B<i>::Y y); // i is not deduced here
          ^
p419-3.cpp:10:10: error: expected '(' before 'B'
p419-3.cpp:11:1: error: 'A' does not name a type
 A<int> a;
 ^
p419-3.cpp:12:1: error: 'B' does not name a type
 B<77> b;
 ^
p419-3.cpp:13:9: error: wrong number of template arguments (1, should be 2)
 int x = deduce<77>(a.xm, 62, b.ym);
         ^~~~~~~~~~
p419-3.cpp:8:19: note: provided for 'template<int i, class T> T deduce<i, T>'
 T deduce(typename A<T>::X x, // T is not deduced here
                   ^
p419-3.cpp:13:20: error: 'a' was not declared in this scope
 int x = deduce<77>(a.xm, 62, b.ym);
                    ^
p419-3.cpp:13:30: error: 'b' was not declared in this scope
 int x = deduce<77>(a.xm, 62, b.ym);
                              ^
p419-3.cpp: In function 'void k1()':
p419-3.cpp:22:4: error: no matching function for call to 'f(A<1>&)'
 f(a); // error: deduction fails for conversion from int to short
    ^
p419-3.cpp:19:24: note: candidate: template<short int s> void f(A<s>)
 template<short s> void f(A<s>);
                        ^
p419-3.cpp:19:24: note:   template argument deduction/substitution failed:
p419-3.cpp:22:4: note:   mismatched types 'short int' and 'int'
 f(a); // error: deduction fails for conversion from int to short
    ^
p419-3.cpp: In function 'int m()':
p419-3.cpp:39:5: error: no matching function for call to 'f(<unresolved overloaded function type>)'
 f(&g); // error: ambiguous
     ^
p419-3.cpp:19:24: note: candidate: template<short int s> void f(A<s>)
 template<short s> void f(A<s>);
                        ^
p419-3.cpp:19:24: note:   template argument deduction/substitution failed:
p419-3.cpp:39:5: note:   mismatched types 'A<s>' and 'void (*)(char, int)'
 f(&g); // error: ambiguous
     ^
p419-3.cpp:39:5: note:   mismatched types 'A<s>' and 'void (*)(int, int)'
p419-3.cpp:39:5: note:   couldn't deduce template parameter 's'
p419-3.cpp:32:24: note: candidate: template<class T> void f(void (*)(T, int))
 template<class T> void f(void(*)(T,int));
                        ^
p419-3.cpp:32:24: note:   template argument deduction/substitution failed:
p419-3.cpp:39:5: note:   couldn't deduce template parameter 'T'
 f(&g); // error: ambiguous
     ^
p419-3.cpp:41:7: error: no matching function for call to 'f(<unresolved overloaded function type>)'
 f(&foo); // error: type deduction fails because foo is a template
       ^
p419-3.cpp:19:24: note: candidate: template<short int s> void f(A<s>)
 template<short s> void f(A<s>);
                        ^
p419-3.cpp:19:24: note:   template argument deduction/substitution failed:
p419-3.cpp:41:7: note:   couldn't deduce template parameter 's'
 f(&foo); // error: type deduction fails because foo is a template
       ^
p419-3.cpp:32:24: note: candidate: template<class T> void f(void (*)(T, int))
 template<class T> void f(void(*)(T,int));
                        ^
p419-3.cpp:32:24: note:   template argument deduction/substitution failed:
p419-3.cpp:41:7: note:   couldn't deduce template parameter 'T'
 f(&foo); // error: type deduction fails because foo is a template
       ^
p419-3.cpp: In function 'void g()':
p419-3.cpp:47:3: error: no matching function for call to 'f()'
 f(); // error: cannot deduce T
   ^
p419-3.cpp:19:24: note: candidate: template<short int s> void f(A<s>)
 template<short s> void f(A<s>);
                        ^
p419-3.cpp:19:24: note:   template argument deduction/substitution failed:
p419-3.cpp:47:3: note:   candidate expects 1 argument, 0 provided
 f(); // error: cannot deduce T
   ^
p419-3.cpp:32:24: note: candidate: template<class T> void f(void (*)(T, int))
 template<class T> void f(void(*)(T,int));
                        ^
p419-3.cpp:32:24: note:   template argument deduction/substitution failed:
p419-3.cpp:47:3: note:   candidate expects 1 argument, 0 provided
 f(); // error: cannot deduce T
   ^
p419-3.cpp:44:25: note: candidate: template<class T> void f(T, T)
 template <class T> void f(T = 5, T = 7);
                         ^
p419-3.cpp:44:25: note:   template argument deduction/substitution failed:
p419-3.cpp:47:3: note:   couldn't deduce template parameter 'T'
 f(); // error: cannot deduce T
   ^
p419-3.cpp: At global scope:
p419-3.cpp:18:14: error: template parameter 'int i'
 template<int i> class A { /* ... */ };
              ^
p419-3.cpp:51:46: error: redeclared here as 'template<class T> class X'
 template <template <class T> class X> struct A { };
                                              ^
p419-3.cpp:52:49: error: type/value mismatch at argument 1 in template parameter list for 'template<int i> class A'
 template <template <class T> class X> void f(A<X>) { }
                                                 ^
p419-3.cpp:52:49: note:   expected a constant of type 'int', got 'X'
p419-3.cpp:25:22: error: template parameter 'short int cs'
 template<const short cs> class B { };
                      ^~
p419-3.cpp:53:26: error: redeclared here as 'class T'
 template<class T> struct B { };
                          ^
p419-3.cpp:54:4: error: type/value mismatch at argument 1 in template parameter list for 'template<int i> class A'
 A<B> ab;
    ^
p419-3.cpp:54:4: note:   expected a constant of type 'int', got 'B'
p419-3.cpp:55:2: error: expected constructor, destructor, or type conversion before '(' token
 f(ab); // calls f(A<B>)
  ^

#!/bin/bash
astyle -s2 -c < $1.cpp > $1s2.cpp
cat $1s2.cpp