Index: libcfa/src/concurrency/mutex_stmt.hfa
===================================================================
--- libcfa/src/concurrency/mutex_stmt.hfa	(revision f2a1cd2558fcfcacb2b0ab75ebaafd98d36465fa)
+++ libcfa/src/concurrency/mutex_stmt.hfa	(revision dd3576b74599ea86e0c5b495315a213a3519cd0b)
@@ -4,5 +4,6 @@
 //-----------------------------------------------------------------------------
 // is_lock
-trait is_lock(L & | sized(L)) {
+forall(L & | sized(L))
+trait is_lock {
 	// For acquiring a lock
 	void lock( L & );
Index: libcfa/src/vec/vec.hfa
===================================================================
--- libcfa/src/vec/vec.hfa	(revision f2a1cd2558fcfcacb2b0ab75ebaafd98d36465fa)
+++ libcfa/src/vec/vec.hfa	(revision dd3576b74599ea86e0c5b495315a213a3519cd0b)
@@ -18,35 +18,46 @@
 #include <math.hfa>
 
-trait fromint(T) {
+forall(T)
+trait fromint {
     void ?{}(T&, int);
 };
-trait zeroinit(T) {
+forall(T)
+trait zeroinit {
     void ?{}(T&, zero_t);
 };
-trait zero_assign(T) {
+forall(T)
+trait zero_assign {
     T ?=?(T&, zero_t);
 };
-trait subtract(T) {
+forall(T)
+trait subtract {
     T ?-?(T, T);
 };
-trait negate(T) {
+forall(T)
+trait negate {
     T -?(T);
 };
-trait add(T) {
+forall(T)
+trait add {
     T ?+?(T, T);
 };
-trait multiply(T) {
+forall(T)
+trait multiply {
     T ?*?(T, T);
 };
-trait divide(T) {
+forall(T)
+trait divide {
     T ?/?(T, T);
 };
-trait lessthan(T) {
+forall(T)
+trait lessthan {
     int ?<?(T, T);
 };
-trait equality(T) {
+forall(T)
+trait equality {
     int ?==?(T, T);
 };
-trait sqrt(T) {
+forall(T)
+trait sqrt {
     T sqrt(T);
 };
Index: tests/avltree/avl.h
===================================================================
--- tests/avltree/avl.h	(revision f2a1cd2558fcfcacb2b0ab75ebaafd98d36465fa)
+++ tests/avltree/avl.h	(revision dd3576b74599ea86e0c5b495315a213a3519cd0b)
@@ -9,5 +9,6 @@
 // #include <lib.h>
 
-trait Comparable(T) {
+forall(T)
+trait Comparable {
   int ?<?(T, T);
 };
Index: tests/function-operator.cfa
===================================================================
--- tests/function-operator.cfa	(revision f2a1cd2558fcfcacb2b0ab75ebaafd98d36465fa)
+++ tests/function-operator.cfa	(revision dd3576b74599ea86e0c5b495315a213a3519cd0b)
@@ -10,6 +10,6 @@
 // Created On       : Fri Aug 25 15:21:11 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 11 18:27:45 2019
-// Update Count     : 10
+// Last Modified On : Sat Feb 25 07:26:10 2023
+// Update Count     : 12
 //
 
@@ -22,7 +22,10 @@
 
 // STL-like Algorithms
-trait Assignable(T &, U &) { T ?=?(T &, U); };
-trait Copyable(T &) { void ?{}(T &, T); };
-trait Destructable(T &) { void ^?{}(T &); };
+forall(T &, U &)
+trait Assignable { T ?=?(T &, U); };
+forall(T &)
+trait Copyable { void ?{}(T &, T); };
+forall(T &)
+trait Destructable { void ^?{}(T &); };
 
 trait Iterator(iter & | sized(iter) | Copyable(iter) | Destructable(iter), T) {
Index: tests/sum.cfa
===================================================================
--- tests/sum.cfa	(revision f2a1cd2558fcfcacb2b0ab75ebaafd98d36465fa)
+++ tests/sum.cfa	(revision dd3576b74599ea86e0c5b495315a213a3519cd0b)
@@ -11,6 +11,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  5 21:27:25 2021
-// Update Count     : 346
+// Last Modified On : Fri Feb 24 22:52:12 2023
+// Update Count     : 347
 //
 
@@ -18,5 +18,6 @@
 #include <stdlib.hfa>
 
-trait sumable( T ) {
+forall( T )
+trait sumable {
 	void ?{}( T &, zero_t );							// 0 literal constructor
 	void ?{}( T &, one_t );								// 1 literal constructor