Index: libcfa/src/concurrency/atomic.hfa
===================================================================
--- libcfa/src/concurrency/atomic.hfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/concurrency/atomic.hfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -10,22 +10,42 @@
 // Created On       : Thu May 25 15:22:46 2023
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May 25 15:24:45 2023
-// Update Count     : 1
+// Last Modified On : Fri Jun  9 13:36:47 2023
+// Update Count     : 46
 // 
 
-#define LOAD( lock ) (__atomic_load_n( &(lock), __ATOMIC_SEQ_CST ))
-#define LOADM( lock, memorder ) (__atomic_load_n( &(lock), memorder ))
-#define STORE( lock, assn ) (__atomic_store_n( &(lock), assn, __ATOMIC_SEQ_CST ))
-#define STOREM( lock, assn, memorder ) (__atomic_store_n( &(lock), assn, memorder ))
-#define CLR( lock ) (__atomic_clear( &(lock), __ATOMIC_RELEASE ))
-#define CLRM( lock, memorder ) (__atomic_clear( &(lock), memorder ))
-#define TAS( lock ) (__atomic_test_and_set( &(lock), __ATOMIC_ACQUIRE ))
-#define TASM( lock, memorder ) (__atomic_test_and_set( &(lock), memorder ))
-#define CAS( change, comp, assn ) ({typeof(comp) __temp = (comp); __atomic_compare_exchange_n( &(change), &(__temp), (assn), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ); })
-#define CASM( change, comp, assn, memorder... ) ({typeof(comp) * __temp = &(comp); __atomic_compare_exchange_n( &(change), &(__temp), (assn), false, memorder, memorder ); })
-#define CASV( change, comp, assn ) (__atomic_compare_exchange_n( &(change), &(comp), (assn), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ))
-#define CASVM( change, comp, assn, memorder... ) (__atomic_compare_exchange_n( &(change), &(comp), (assn), false, memorder, memorder ))
-#define FAS( change, assn ) (__atomic_exchange_n( &(change), (assn), __ATOMIC_SEQ_CST ))
-#define FASM( change, assn, memorder ) (__atomic_exchange_n( &(change), (assn), memorder ))
-#define FAI( change, Inc ) (__atomic_fetch_add( &(change), (Inc), __ATOMIC_SEQ_CST ))
-#define FAIM( change, Inc, memorder ) (__atomic_fetch_add( &(change), (Inc), memorder ))
+#define LOAD( val ) (LOADM( val, __ATOMIC_SEQ_CST))
+#define LOADM( val, memorder ) (__atomic_load_n( &(val), memorder))
+
+#define STORE( val, assn ) (STOREM( val, assn, __ATOMIC_SEQ_CST))
+#define STOREM( val, assn, memorder ) (__atomic_store_n( &(val), assn, memorder))
+
+#define TAS( lock ) (TASM( lock, __ATOMIC_ACQUIRE))
+#define TASM( lock, memorder ) (__atomic_test_and_set( &(lock), memorder))
+
+#define TASCLR( lock ) (TASCLRM( lock, __ATOMIC_RELEASE))
+#define TASCLRM( lock, memorder ) (__atomic_clear( &(lock), memorder))
+
+#define FAS( assn, replace ) (FASM(assn, replace, __ATOMIC_SEQ_CST))
+#define FASM( assn, replace, memorder ) (__atomic_exchange_n( &(assn), (replace), memorder))
+
+#define FAI( assn, Inc ) (__atomic_fetch_add( &(assn), (Inc), __ATOMIC_SEQ_CST))
+#define FAIM( assn, Inc, memorder ) (__atomic_fetch_add( &(assn), (Inc), memorder))
+
+// Use __sync because __atomic with 128-bit CAA can result in calls to pthread_mutex_lock.
+
+// #define CAS( assn, comp, replace ) (CASM( assn, comp, replace, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST))
+// #define CASM( assn, comp, replace, memorder... ) ({ \
+//  	typeof(comp) __temp = (comp); \
+//  	__atomic_compare_exchange_n( &(assn), &(__temp), (replace), false, memorder ); \
+// })
+#define CAS( assn, comp, replace ) (__sync_bool_compare_and_swap( &assn, comp, replace))
+#define CASM( assn, comp, replace, memorder... ) _Static_assert( false, "memory order unsupported for CAS macro" );
+
+// #define CASV( assn, comp, replace ) (__atomic_compare_exchange_n( &(assn), &(comp), (replace), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ))
+// #define CASVM( assn, comp, replace, memorder... ) (__atomic_compare_exchange_n( &(assn), &(comp), (replace), false, memorder, memorder ))
+#define CASV( assn, comp, replace ) ({ \
+	typeof(comp) temp = comp; \
+	typeof(comp) old = __sync_val_compare_and_swap( &(assn), (comp), (replace) ); \
+	old == temp ? true : (comp = old, false); \
+})
+#define CASVM( assn, comp, replace, memorder... ) _Static_assert( false, "memory order unsupported for CASV macro" );
Index: libcfa/src/containers/lockfree.hfa
===================================================================
--- libcfa/src/containers/lockfree.hfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/containers/lockfree.hfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -199,9 +199,12 @@
 
 forall( T & )
+struct LinkData {
+	T * volatile top;								// pointer to stack top
+	uintptr_t count;								// count each push
+};
+
+forall( T & )
 union Link {
-	struct {											// 32/64-bit x 2
-		T * volatile top;								// pointer to stack top
-		uintptr_t count;								// count each push
-	};
+	LinkData(T) data;
 	#if __SIZEOF_INT128__ == 16
 	__int128											// gcc, 128-bit integer
@@ -220,10 +223,10 @@
 		void ?{}( StackLF(T) & this ) with(this) { stack.atom = 0; }
 
-		T * top( StackLF(T) & this ) with(this) { return stack.top; }
+		T * top( StackLF(T) & this ) with(this) { return stack.data.top; }
 
 		void push( StackLF(T) & this, T & n ) with(this) {
 			*( &n )`next = stack;						// atomic assignment unnecessary, or use CAA
 			for () {									// busy wait
-			  if ( __atomic_compare_exchange_n( &stack.atom, &( &n )`next->atom, (Link(T))@{ {&n, ( &n )`next->count + 1} }.atom, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) break; // attempt to update top node
+				if ( __atomic_compare_exchange_n( &stack.atom, &( &n )`next->atom, (Link(T))@{ (LinkData(T))@{ &n, ( &n )`next->data.count + 1} }.atom, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) break; // attempt to update top node
 			} // for
 		} // push
@@ -232,6 +235,7 @@
 			Link(T) t @= stack;							// atomic assignment unnecessary, or use CAA
 			for () {									// busy wait
-			  if ( t.top == 0p ) return 0p;				// empty stack ?
-			  if ( __atomic_compare_exchange_n( &stack.atom, &t.atom, (Link(T))@{ {( t.top )`next->top, t.count} }.atom, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) return t.top; // attempt to update top node
+				if ( t.data.top == 0p ) return 0p;				// empty stack ?
+				Link(T) * next = ( t.data.top )`next;
+				if ( __atomic_compare_exchange_n( &stack.atom, &t.atom, (Link(T))@{ (LinkData(T))@{ next->data.top, t.data.count } }.atom, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) return t.data.top; // attempt to update top node
 			} // for
 		} // pop
@@ -239,11 +243,13 @@
 		bool unsafe_remove( StackLF(T) & this, T * node ) with(this) {
 			Link(T) * link = &stack;
-			for() {
-				T * next = link->top;
-				if( next == node ) {
-					link->top = ( node )`next->top;
+			for () {
+				// TODO: Avoiding some problems with double fields access.
+				LinkData(T) * data = &link->data;
+				T * next = (T *)&(*data).top;
+				if ( next == node ) {
+					data->top = ( node )`next->data.top;
 					return true;
 				}
-				if( next == 0p ) return false;
+				if ( next == 0p ) return false;
 				link = ( next )`next;
 			}
Index: libcfa/src/fstream.cfa
===================================================================
--- libcfa/src/fstream.cfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/fstream.cfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr  9 14:55:54 2022
-// Update Count     : 515
+// Last Modified On : Mon Jun  5 22:00:23 2023
+// Update Count     : 518
 //
 
@@ -117,5 +117,5 @@
     } // for
 	if ( file == 0p ) {
-		throw (Open_Failure){ os };
+		throw (open_failure){ os };
 		// abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
 	} // if
@@ -137,5 +137,5 @@
     } // for
 	if ( ret == EOF ) {
-		throw (Close_Failure){ os };
+		throw (close_failure){ os };
 		// abort | IO_MSG "close output" | nl | strerror( errno );
 	} // if
@@ -145,10 +145,10 @@
 ofstream & write( ofstream & os, const char data[], size_t size ) {
 	if ( fail( os ) ) {
-		throw (Write_Failure){ os };
+		throw (write_failure){ os };
 		// abort | IO_MSG "attempt write I/O on failed stream";
 	} // if
 
 	if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
-		throw (Write_Failure){ os };
+		throw (write_failure){ os };
 		// abort | IO_MSG "write" | nl | strerror( errno );
 	} // if
@@ -240,5 +240,5 @@
     } // for
 	if ( file == 0p ) {
-		throw (Open_Failure){ is };
+		throw (open_failure){ is };
 		// abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
 	} // if
@@ -260,5 +260,5 @@
     } // for
 	if ( ret == EOF ) {
-		throw (Close_Failure){ is };
+		throw (close_failure){ is };
 		// abort | IO_MSG "close input" | nl | strerror( errno );
 	} // if
@@ -268,10 +268,10 @@
 ifstream & read( ifstream & is, char data[], size_t size ) {
 	if ( fail( is ) ) {
-		throw (Read_Failure){ is };
+		throw (read_failure){ is };
 		// abort | IO_MSG "attempt read I/O on failed stream";
 	} // if
 
 	if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
-		throw (Read_Failure){ is };
+		throw (read_failure){ is };
 		// abort | IO_MSG "read" | nl | strerror( errno );
 	} // if
@@ -318,15 +318,15 @@
 
 
-static vtable(Open_Failure) Open_Failure_vt;
+static vtable(open_failure) open_failure_vt;
 
 // exception I/O constructors
-void ?{}( Open_Failure & ex, ofstream & ostream ) with(ex) {
-	virtual_table = &Open_Failure_vt;
+void ?{}( open_failure & ex, ofstream & ostream ) with(ex) {
+	virtual_table = &open_failure_vt;
 	ostream = &ostream;
 	tag = 1;
 } // ?{}
 
-void ?{}( Open_Failure & ex, ifstream & istream ) with(ex) {
-	virtual_table = &Open_Failure_vt;
+void ?{}( open_failure & ex, ifstream & istream ) with(ex) {
+	virtual_table = &open_failure_vt;
 	istream = &istream;
 	tag = 0;
@@ -334,15 +334,15 @@
 
 
-static vtable(Close_Failure) Close_Failure_vt;
+static vtable(close_failure) close_failure_vt;
 
 // exception I/O constructors
-void ?{}( Close_Failure & ex, ofstream & ostream ) with(ex) {
-	virtual_table = &Close_Failure_vt;
+void ?{}( close_failure & ex, ofstream & ostream ) with(ex) {
+	virtual_table = &close_failure_vt;
 	ostream = &ostream;
 	tag = 1;
 } // ?{}
 
-void ?{}( Close_Failure & ex, ifstream & istream ) with(ex) {
-	virtual_table = &Close_Failure_vt;
+void ?{}( close_failure & ex, ifstream & istream ) with(ex) {
+	virtual_table = &close_failure_vt;
 	istream = &istream;
 	tag = 0;
@@ -350,15 +350,15 @@
 
 
-static vtable(Write_Failure) Write_Failure_vt;
+static vtable(write_failure) write_failure_vt;
 
 // exception I/O constructors
-void ?{}( Write_Failure & ex, ofstream & ostream ) with(ex) {
-	virtual_table = &Write_Failure_vt;
+void ?{}( write_failure & ex, ofstream & ostream ) with(ex) {
+	virtual_table = &write_failure_vt;
 	ostream = &ostream;
 	tag = 1;
 } // ?{}
 
-void ?{}( Write_Failure & ex, ifstream & istream ) with(ex) {
-	virtual_table = &Write_Failure_vt;
+void ?{}( write_failure & ex, ifstream & istream ) with(ex) {
+	virtual_table = &write_failure_vt;
 	istream = &istream;
 	tag = 0;
@@ -366,25 +366,25 @@
 
 
-static vtable(Read_Failure) Read_Failure_vt;
+static vtable(read_failure) read_failure_vt;
 
 // exception I/O constructors
-void ?{}( Read_Failure & ex, ofstream & ostream ) with(ex) {
-	virtual_table = &Read_Failure_vt;
+void ?{}( read_failure & ex, ofstream & ostream ) with(ex) {
+	virtual_table = &read_failure_vt;
 	ostream = &ostream;
 	tag = 1;
 } // ?{}
 
-void ?{}( Read_Failure & ex, ifstream & istream ) with(ex) {
-	virtual_table = &Read_Failure_vt;
+void ?{}( read_failure & ex, ifstream & istream ) with(ex) {
+	virtual_table = &read_failure_vt;
 	istream = &istream;
 	tag = 0;
 } // ?{}
 
-// void throwOpen_Failure( ofstream & ostream ) {
-// 	Open_Failure exc = { ostream };
+// void throwopen_failure( ofstream & ostream ) {
+// 	open_failure exc = { ostream };
 // }
 
-// void throwOpen_Failure( ifstream & istream ) {
-// 	Open_Failure exc = { istream };
+// void throwopen_failure( ifstream & istream ) {
+// 	open_failure exc = { istream };
 // }
 
Index: libcfa/src/fstream.hfa
===================================================================
--- libcfa/src/fstream.hfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/fstream.hfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 09:37:32 2021
-// Update Count     : 243
+// Last Modified On : Mon Jun  5 22:00:20 2023
+// Update Count     : 246
 //
 
@@ -137,5 +137,5 @@
 
 
-exception Open_Failure {
+exception open_failure {
 	union {
 		ofstream * ostream;
@@ -146,8 +146,8 @@
 };
 
-void ?{}( Open_Failure & this, ofstream & );
-void ?{}( Open_Failure & this, ifstream & );
+void ?{}( open_failure & this, ofstream & );
+void ?{}( open_failure & this, ifstream & );
 
-exception Close_Failure {
+exception close_failure {
 	union {
 		ofstream * ostream;
@@ -158,8 +158,8 @@
 };
 
-void ?{}( Close_Failure & this, ofstream & );
-void ?{}( Close_Failure & this, ifstream & );
+void ?{}( close_failure & this, ofstream & );
+void ?{}( close_failure & this, ifstream & );
 
-exception Write_Failure {
+exception write_failure {
 	union {
 		ofstream * ostream;
@@ -170,8 +170,8 @@
 };
 
-void ?{}( Write_Failure & this, ofstream & );
-void ?{}( Write_Failure & this, ifstream & );
+void ?{}( write_failure & this, ofstream & );
+void ?{}( write_failure & this, ifstream & );
 
-exception Read_Failure {
+exception read_failure {
 	union {
 		ofstream * ostream;
@@ -182,6 +182,6 @@
 };
 
-void ?{}( Read_Failure & this, ofstream & );
-void ?{}( Read_Failure & this, ifstream & );
+void ?{}( read_failure & this, ofstream & );
+void ?{}( read_failure & this, ifstream & );
 
 // Local Variables: //
Index: libcfa/src/math.trait.hfa
===================================================================
--- libcfa/src/math.trait.hfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/math.trait.hfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -10,6 +10,6 @@
 // Created On       : Fri Jul 16 15:40:52 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  2 11:36:56 2023
-// Update Count     : 20
+// Last Modified On : Tue Jun  6 07:59:17 2023
+// Update Count     : 24
 // 
 
@@ -17,25 +17,25 @@
 
 forall( U )
-trait Not {
+trait not {
 	void ?{}( U &, zero_t );
 	int !?( U );
-}; // Not
+}; // not
 
-forall( T | Not( T ) )
-trait Equality {
+forall( T | not( T ) )
+trait equality {
 	int ?==?( T, T );
 	int ?!=?( T, T );
-}; // Equality
+}; // equality
 
-forall( U | Equality( U ) )
-trait Relational {
+forall( U | equality( U ) )
+trait relational {
 	int ?<?( U, U );
 	int ?<=?( U, U );
 	int ?>?( U, U );
 	int ?>=?( U, U );
-}; // Relational
+}; // relational
 
 forall ( T )
-trait Signed {
+trait Signed {	// must be capitalized, conflict with keyword signed
 	T +?( T );
 	T -?( T );
@@ -44,13 +44,13 @@
 
 forall( U | Signed( U ) )
-trait Additive {
+trait additive {
 	U ?+?( U, U );
 	U ?-?( U, U );
 	U ?+=?( U &, U );
 	U ?-=?( U &, U );
-}; // Additive
+}; // additive
 
-forall( T | Additive( T ) )
-trait Incdec {
+forall( T | additive( T ) )
+trait inc_dec {
 	void ?{}( T &, one_t );
 	// T ?++( T & );
@@ -58,17 +58,17 @@
 	// T ?--( T & );
 	// T --?( T & );
-}; // Incdec
+}; // inc_dec
 
-forall( U | Incdec( U ) )
-trait Multiplicative {
+forall( U | inc_dec( U ) )
+trait multiplicative {
 	U ?*?( U, U );
 	U ?/?( U, U );
 	U ?%?( U, U );
 	U ?/=?( U &, U );
-}; // Multiplicative
+}; // multiplicative
 
-forall( T | Relational( T ) | Multiplicative( T ) )
-trait Arithmetic {
-}; // Arithmetic
+forall( T | relational( T ) | multiplicative( T ) )
+trait arithmetic {
+}; // arithmetic
 
 // Local Variables: //
Index: libcfa/src/parseconfig.cfa
===================================================================
--- libcfa/src/parseconfig.cfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/parseconfig.cfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -144,5 +144,5 @@
 			in | nl;								// ignore remainder of line
 		} // for
-	} catch( Open_Failure * ex; ex->istream == &in ) {
+	} catch( open_failure * ex; ex->istream == &in ) {
 		delete( kv_pairs );
 		throw *ex;
@@ -203,5 +203,5 @@
 
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_nonnegative( & T value ) {
 	T zero_val = 0;
@@ -209,5 +209,5 @@
 }
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_positive( & T value ) {
 	T zero_val = 0;
@@ -215,5 +215,5 @@
 }
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_nonpositive( & T value ) {
 	T zero_val = 0;
@@ -221,5 +221,5 @@
 }
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_negative( & T value ) {
 	T zero_val = 0;
Index: libcfa/src/parseconfig.hfa
===================================================================
--- libcfa/src/parseconfig.hfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/parseconfig.hfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -107,14 +107,14 @@
 
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_nonnegative( & T );
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_positive( & T );
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_nonpositive( & T );
 
-forall(T | Relational( T ))
+forall(T | relational( T ))
 [ bool ] is_negative( & T );
 
Index: libcfa/src/rational.cfa
===================================================================
--- libcfa/src/rational.cfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/rational.cfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -10,6 +10,6 @@
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 25 18:09:58 2022
-// Update Count     : 194
+// Last Modified On : Mon Jun  5 22:49:06 2023
+// Update Count     : 196
 //
 
@@ -20,5 +20,5 @@
 #pragma GCC visibility push(default)
 
-forall( T | Arithmetic( T ) ) {
+forall( T | arithmetic( T ) ) {
 	// helper routines
 
@@ -39,28 +39,28 @@
 			abort | "Invalid rational number construction: denominator cannot be equal to 0.";
 		} // exit
-		if ( d < (T){0} ) { d = -d; n = -n; } // move sign to numerator
+		if ( d < (T){0} ) { d = -d; n = -n; }			// move sign to numerator
 		return gcd( abs( n ), d );						// simplify
-	} // Rationalnumber::simplify
+	} // simplify
 
 	// constructors
 
-	void ?{}( Rational(T) & r, zero_t ) {
+	void ?{}( rational(T) & r, zero_t ) {
 		r{ (T){0}, (T){1} };
 	} // rational
 
-	void ?{}( Rational(T) & r, one_t ) {
+	void ?{}( rational(T) & r, one_t ) {
 		r{ (T){1}, (T){1} };
 	} // rational
 
-	void ?{}( Rational(T) & r ) {
+	void ?{}( rational(T) & r ) {
 		r{ (T){0}, (T){1} };
 	} // rational
 
-	void ?{}( Rational(T) & r, T n ) {
+	void ?{}( rational(T) & r, T n ) {
 		r{ n, (T){1} };
 	} // rational
 
-	void ?{}( Rational(T) & r, T n, T d ) {
-		T t = simplify( n, d );				// simplify
+	void ?{}( rational(T) & r, T n, T d ) {
+		T t = simplify( n, d );							// simplify
 		r.[numerator, denominator] = [n / t, d / t];
 	} // rational
@@ -68,13 +68,13 @@
 	// getter for numerator/denominator
 
-	T numerator( Rational(T) r ) {
+	T numerator( rational(T) r ) {
 		return r.numerator;
 	} // numerator
 
-	T denominator( Rational(T) r ) {
+	T denominator( rational(T) r ) {
 		return r.denominator;
 	} // denominator
 
-	[ T, T ] ?=?( & [ T, T ] dest, Rational(T) src ) {
+	[ T, T ] ?=?( & [ T, T ] dest, rational(T) src ) {
 		return dest = src.[ numerator, denominator ];
 	} // ?=?
@@ -82,14 +82,14 @@
 	// setter for numerator/denominator
 
-	T numerator( Rational(T) r, T n ) {
+	T numerator( rational(T) r, T n ) {
 		T prev = r.numerator;
-		T t = gcd( abs( n ), r.denominator ); // simplify
+		T t = gcd( abs( n ), r.denominator );			// simplify
 		r.[numerator, denominator] = [n / t, r.denominator / t];
 		return prev;
 	} // numerator
 
-	T denominator( Rational(T) r, T d ) {
+	T denominator( rational(T) r, T d ) {
 		T prev = r.denominator;
-		T t = simplify( r.numerator, d );	// simplify
+		T t = simplify( r.numerator, d );				// simplify
 		r.[numerator, denominator] = [r.numerator / t, d / t];
 		return prev;
@@ -98,29 +98,29 @@
 	// comparison
 
-	int ?==?( Rational(T) l, Rational(T) r ) {
+	int ?==?( rational(T) l, rational(T) r ) {
 		return l.numerator * r.denominator == l.denominator * r.numerator;
 	} // ?==?
 
-	int ?!=?( Rational(T) l, Rational(T) r ) {
+	int ?!=?( rational(T) l, rational(T) r ) {
 		return ! ( l == r );
 	} // ?!=?
 
-	int ?!=?( Rational(T) l, zero_t ) {
-		return ! ( l == (Rational(T)){ 0 } );
+	int ?!=?( rational(T) l, zero_t ) {
+		return ! ( l == (rational(T)){ 0 } );
 	} // ?!=?
 
-	int ?<?( Rational(T) l, Rational(T) r ) {
+	int ?<?( rational(T) l, rational(T) r ) {
 		return l.numerator * r.denominator < l.denominator * r.numerator;
 	} // ?<?
 
-	int ?<=?( Rational(T) l, Rational(T) r ) {
+	int ?<=?( rational(T) l, rational(T) r ) {
 		return l.numerator * r.denominator <= l.denominator * r.numerator;
 	} // ?<=?
 
-	int ?>?( Rational(T) l, Rational(T) r ) {
+	int ?>?( rational(T) l, rational(T) r ) {
 		return ! ( l <= r );
 	} // ?>?
 
-	int ?>=?( Rational(T) l, Rational(T) r ) {
+	int ?>=?( rational(T) l, rational(T) r ) {
 		return ! ( l < r );
 	} // ?>=?
@@ -128,64 +128,64 @@
 	// arithmetic
 
-	Rational(T) +?( Rational(T) r ) {
-		return (Rational(T)){ r.numerator, r.denominator };
+	rational(T) +?( rational(T) r ) {
+		return (rational(T)){ r.numerator, r.denominator };
 	} // +?
 
-	Rational(T) -?( Rational(T) r ) {
-		return (Rational(T)){ -r.numerator, r.denominator };
+	rational(T) -?( rational(T) r ) {
+		return (rational(T)){ -r.numerator, r.denominator };
 	} // -?
 
-	Rational(T) ?+?( Rational(T) l, Rational(T) r ) {
+	rational(T) ?+?( rational(T) l, rational(T) r ) {
 		if ( l.denominator == r.denominator ) {			// special case
-			return (Rational(T)){ l.numerator + r.numerator, l.denominator };
+			return (rational(T)){ l.numerator + r.numerator, l.denominator };
 		} else {
-			return (Rational(T)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
+			return (rational(T)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
 		} // if
 	} // ?+?
 
-	Rational(T) ?+=?( Rational(T) & l, Rational(T) r ) {
+	rational(T) ?+=?( rational(T) & l, rational(T) r ) {
 		l = l + r;
 		return l;
 	} // ?+?
 
-	Rational(T) ?+=?( Rational(T) & l, one_t ) {
-		l = l + (Rational(T)){ 1 };
+	rational(T) ?+=?( rational(T) & l, one_t ) {
+		l = l + (rational(T)){ 1 };
 		return l;
 	} // ?+?
 
-	Rational(T) ?-?( Rational(T) l, Rational(T) r ) {
+	rational(T) ?-?( rational(T) l, rational(T) r ) {
 		if ( l.denominator == r.denominator ) {			// special case
-			return (Rational(T)){ l.numerator - r.numerator, l.denominator };
+			return (rational(T)){ l.numerator - r.numerator, l.denominator };
 		} else {
-			return (Rational(T)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
+			return (rational(T)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
 		} // if
 	} // ?-?
 
-	Rational(T) ?-=?( Rational(T) & l, Rational(T) r ) {
+	rational(T) ?-=?( rational(T) & l, rational(T) r ) {
 		l = l - r;
 		return l;
 	} // ?-?
 
-	Rational(T) ?-=?( Rational(T) & l, one_t ) {
-		l = l - (Rational(T)){ 1 };
+	rational(T) ?-=?( rational(T) & l, one_t ) {
+		l = l - (rational(T)){ 1 };
 		return l;
 	} // ?-?
 
-	Rational(T) ?*?( Rational(T) l, Rational(T) r ) {
-		return (Rational(T)){ l.numerator * r.numerator, l.denominator * r.denominator };
+	rational(T) ?*?( rational(T) l, rational(T) r ) {
+		return (rational(T)){ l.numerator * r.numerator, l.denominator * r.denominator };
 	} // ?*?
 
-	Rational(T) ?*=?( Rational(T) & l, Rational(T) r ) {
+	rational(T) ?*=?( rational(T) & l, rational(T) r ) {
 		return l = l * r;
 	} // ?*?
 
-	Rational(T) ?/?( Rational(T) l, Rational(T) r ) {
+	rational(T) ?/?( rational(T) l, rational(T) r ) {
 		if ( r.numerator < (T){0} ) {
 			r.[numerator, denominator] = [-r.numerator, -r.denominator];
 		} // if
-		return (Rational(T)){ l.numerator * r.denominator, l.denominator * r.numerator };
+		return (rational(T)){ l.numerator * r.denominator, l.denominator * r.numerator };
 	} // ?/?
 
-	Rational(T) ?/=?( Rational(T) & l, Rational(T) r ) {
+	rational(T) ?/=?( rational(T) & l, rational(T) r ) {
 		return l = l / r;
 	} // ?/?
@@ -194,5 +194,5 @@
 
 	forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } )
-	istype & ?|?( istype & is, Rational(T) & r ) {
+	istype & ?|?( istype & is, rational(T) & r ) {
 		is | r.numerator | r.denominator;
 		T t = simplify( r.numerator, r.denominator );
@@ -203,9 +203,9 @@
 
 	forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, T ); } ) {
-		ostype & ?|?( ostype & os, Rational(T) r ) {
+		ostype & ?|?( ostype & os, rational(T) r ) {
 			return os | r.numerator | '/' | r.denominator;
 		} // ?|?
 
-		void ?|?( ostype & os, Rational(T) r ) {
+		void ?|?( ostype & os, rational(T) r ) {
 			(ostype &)(os | r); ends( os );
 		} // ?|?
@@ -213,14 +213,14 @@
 } // distribution
 
-forall( T | Arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
-	Rational(T) ?\?( Rational(T) x, long int y ) {
+forall( T | arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
+	rational(T) ?\?( rational(T) x, long int y ) {
 		if ( y < 0 ) {
-			return (Rational(T)){ x.denominator \ -y, x.numerator \ -y };
+			return (rational(T)){ x.denominator \ -y, x.numerator \ -y };
 		} else {
-			return (Rational(T)){ x.numerator \ y, x.denominator \ y };
+			return (rational(T)){ x.numerator \ y, x.denominator \ y };
 		} // if
 	} // ?\?
 
-	Rational(T) ?\=?( Rational(T) & x, long int y ) {
+	rational(T) ?\=?( rational(T) & x, long int y ) {
 		return x = x \ y;
 	} // ?\?
@@ -229,14 +229,14 @@
 // conversion
 
-forall( T | Arithmetic( T ) | { double convert( T ); } )
-double widen( Rational(T) r ) {
+forall( T | arithmetic( T ) | { double convert( T ); } )
+double widen( rational(T) r ) {
  	return convert( r.numerator ) / convert( r.denominator );
 } // widen
 
-forall( T | Arithmetic( T ) | { double convert( T ); T convert( double ); } )
-Rational(T) narrow( double f, T md ) {
+forall( T | arithmetic( T ) | { double convert( T ); T convert( double ); } )
+rational(T) narrow( double f, T md ) {
 	// http://www.ics.uci.edu/~eppstein/numth/frap.c
-	if ( md <= (T){1} ) {					// maximum fractional digits too small?
-		return (Rational(T)){ convert( f ), (T){1}}; // truncate fraction
+	if ( md <= (T){1} ) {								// maximum fractional digits too small?
+		return (rational(T)){ convert( f ), (T){1}};	// truncate fraction
 	} // if
 
@@ -260,5 +260,5 @@
 	  if ( f > (double)0x7FFFFFFF ) break;				// representation failure
 	} // for
-	return (Rational(T)){ m00, m10 };
+	return (rational(T)){ m00, m10 };
 } // narrow
 
Index: libcfa/src/rational.hfa
===================================================================
--- libcfa/src/rational.hfa	(revision 1db6d707c9c3bb51aa52503723989ef9490a8c10)
+++ libcfa/src/rational.hfa	(revision 0b0a285cb86eb63d47d96868ae2d0f99f753448c)
@@ -12,6 +12,6 @@
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 20 17:45:29 2021
-// Update Count     : 118
+// Last Modified On : Mon Jun  5 22:49:05 2023
+// Update Count     : 119
 //
 
@@ -19,77 +19,77 @@
 
 #include "iostream.hfa"
-#include "math.trait.hfa"								// Arithmetic
+#include "math.trait.hfa"								// arithmetic
 
 // implementation
 
-forall( T | Arithmetic( T ) ) {
-	struct Rational {
+forall( T | arithmetic( T ) ) {
+	struct rational {
 		T numerator, denominator;						// invariant: denominator > 0
-	}; // Rational
+	}; // rational
 
 	// constructors
 
-	void ?{}( Rational(T) & r );
-	void ?{}( Rational(T) & r, zero_t );
-	void ?{}( Rational(T) & r, one_t );
-	void ?{}( Rational(T) & r, T n );
-	void ?{}( Rational(T) & r, T n, T d );
+	void ?{}( rational(T) & r );
+	void ?{}( rational(T) & r, zero_t );
+	void ?{}( rational(T) & r, one_t );
+	void ?{}( rational(T) & r, T n );
+	void ?{}( rational(T) & r, T n, T d );
 
 	// numerator/denominator getter
 
-	T numerator( Rational(T) r );
-	T denominator( Rational(T) r );
-	[ T, T ] ?=?( & [ T, T ] dest, Rational(T) src );
+	T numerator( rational(T) r );
+	T denominator( rational(T) r );
+	[ T, T ] ?=?( & [ T, T ] dest, rational(T) src );
 
 	// numerator/denominator setter
 
-	T numerator( Rational(T) r, T n );
-	T denominator( Rational(T) r, T d );
+	T numerator( rational(T) r, T n );
+	T denominator( rational(T) r, T d );
 
 	// comparison
 
-	int ?==?( Rational(T) l, Rational(T) r );
-	int ?!=?( Rational(T) l, Rational(T) r );
-	int ?!=?( Rational(T) l, zero_t );					// => !
-	int ?<?( Rational(T) l, Rational(T) r );
-	int ?<=?( Rational(T) l, Rational(T) r );
-	int ?>?( Rational(T) l, Rational(T) r );
-	int ?>=?( Rational(T) l, Rational(T) r );
+	int ?==?( rational(T) l, rational(T) r );
+	int ?!=?( rational(T) l, rational(T) r );
+	int ?!=?( rational(T) l, zero_t );					// => !
+	int ?<?( rational(T) l, rational(T) r );
+	int ?<=?( rational(T) l, rational(T) r );
+	int ?>?( rational(T) l, rational(T) r );
+	int ?>=?( rational(T) l, rational(T) r );
 
 	// arithmetic
 
-	Rational(T) +?( Rational(T) r );
-	Rational(T) -?( Rational(T) r );
-	Rational(T) ?+?( Rational(T) l, Rational(T) r );
-	Rational(T) ?+=?( Rational(T) & l, Rational(T) r );
-	Rational(T) ?+=?( Rational(T) & l, one_t );			// => ++?, ?++
-	Rational(T) ?-?( Rational(T) l, Rational(T) r );
-	Rational(T) ?-=?( Rational(T) & l, Rational(T) r );
-	Rational(T) ?-=?( Rational(T) & l, one_t );			// => --?, ?--
-	Rational(T) ?*?( Rational(T) l, Rational(T) r );
-	Rational(T) ?*=?( Rational(T) & l, Rational(T) r );
-	Rational(T) ?/?( Rational(T) l, Rational(T) r );
-	Rational(T) ?/=?( Rational(T) & l, Rational(T) r );
+	rational(T) +?( rational(T) r );
+	rational(T) -?( rational(T) r );
+	rational(T) ?+?( rational(T) l, rational(T) r );
+	rational(T) ?+=?( rational(T) & l, rational(T) r );
+	rational(T) ?+=?( rational(T) & l, one_t );			// => ++?, ?++
+	rational(T) ?-?( rational(T) l, rational(T) r );
+	rational(T) ?-=?( rational(T) & l, rational(T) r );
+	rational(T) ?-=?( rational(T) & l, one_t );			// => --?, ?--
+	rational(T) ?*?( rational(T) l, rational(T) r );
+	rational(T) ?*=?( rational(T) & l, rational(T) r );
+	rational(T) ?/?( rational(T) l, rational(T) r );
+	rational(T) ?/=?( rational(T) & l, rational(T) r );
 
 	// I/O
 	forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } )
-	istype & ?|?( istype &, Rational(T) & );
+	istype & ?|?( istype &, rational(T) & );
 
 	forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, T ); } ) {
-		ostype & ?|?( ostype &, Rational(T) );
-		void ?|?( ostype &, Rational(T) );
+		ostype & ?|?( ostype &, rational(T) );
+		void ?|?( ostype &, rational(T) );
 	} // distribution
 } // distribution
 
-forall( T | Arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
-	Rational(T) ?\?( Rational(T) x, long int y );
-	Rational(T) ?\=?( Rational(T) & x, long int y );
+forall( T | arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
+	rational(T) ?\?( rational(T) x, long int y );
+	rational(T) ?\=?( rational(T) & x, long int y );
 } // distribution
 
 // conversion
-forall( T | Arithmetic( T ) | { double convert( T ); } )
-double widen( Rational(T) r );
-forall( T | Arithmetic( T ) | { double convert( T );  T convert( double );} )
-Rational(T) narrow( double f, T md );
+forall( T | arithmetic( T ) | { double convert( T ); } )
+double widen( rational(T) r );
+forall( T | arithmetic( T ) | { double convert( T );  T convert( double );} )
+rational(T) narrow( double f, T md );
 
 // Local Variables: //