Index: src/libcfa/iostream
===================================================================
--- src/libcfa/iostream	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/iostream	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 16:44:32 2016
-// Update Count     : 81
+// Last Modified On : Wed Mar  2 18:05:27 2016
+// Update Count     : 85
 //
 
@@ -19,5 +19,5 @@
 #include "iterator"
 
-context ostream( dtype ostype ) {
+trait ostream( dtype ostype ) {
 	_Bool sepPrt( ostype * );
 	void sepOn( ostype * );
@@ -35,5 +35,5 @@
 };
 
-context writeable( type T ) {
+trait writeable( otype T ) {
 	forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
 };
@@ -69,13 +69,13 @@
 
 // writes the range [begin, end) to the given stream
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
 void write( iterator_type begin, iterator_type end, os_type *os );
 
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
 void write_reverse( iterator_type begin, iterator_type end, os_type *os );
 
 //---------------------------------------
 
-context istream( dtype istype ) {
+trait istream( dtype istype ) {
 	int fail( istype * );
 	int eof( istype * );
@@ -87,5 +87,5 @@
 };
 
-context readable( type T ) {
+trait readable( otype T ) {
 	forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T );
 };
Index: src/libcfa/iostream.c
===================================================================
--- src/libcfa/iostream.c	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/iostream.c	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 16:20:57 2016
-// Update Count     : 207
+// Last Modified On : Wed Mar  2 18:06:35 2016
+// Update Count     : 208
 //
 
@@ -185,5 +185,5 @@
 //---------------------------------------
 
-forall( type elttype | writeable( elttype ), type iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
 void write( iteratortype begin, iteratortype end, ostype *os ) {
 	void print( elttype i ) { os | i; }
@@ -191,5 +191,5 @@
 } // ?|?
 
-forall( type elttype | writeable( elttype ), type iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
 void write_reverse( iteratortype begin, iteratortype end, ostype *os ) {
 	void print( elttype i ) { os | i; }
Index: src/libcfa/iterator
===================================================================
--- src/libcfa/iterator	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/iterator	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jan 27 23:49:13 2016
-// Update Count     : 7
+// Last Modified On : Wed Mar  2 18:06:05 2016
+// Update Count     : 9
 //
 
@@ -18,5 +18,5 @@
 
 // An iterator can be used to traverse a data structure.
-context iterator( type iterator_type, type elt_type ) {
+trait iterator( otype iterator_type, otype elt_type ) {
 	// point to the next element
 //	iterator_type ?++( iterator_type * );
@@ -32,5 +32,5 @@
 };
 
-context iterator_for( type iterator_type, type collection_type, type elt_type | iterator( iterator_type, elt_type ) ) {
+trait iterator_for( otype iterator_type, otype collection_type, otype elt_type | iterator( iterator_type, elt_type ) ) {
 //	[ iterator_type begin, iterator_type end ] get_iterators( collection_type );
 	iterator_type begin( collection_type );
@@ -38,8 +38,8 @@
 };
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
 
Index: src/libcfa/iterator.c
===================================================================
--- src/libcfa/iterator.c	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/iterator.c	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -10,11 +10,11 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan 26 17:16:07 2016
-// Update Count     : 26
+// Last Modified On : Wed Mar  2 18:08:11 2016
+// Update Count     : 27
 //
 
 #include "iterator"
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
 	for ( iterator_type i = begin; i != end; ++i ) {
@@ -23,5 +23,5 @@
 }
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
 	for ( iterator_type i = end; i != begin; ) {
Index: src/libcfa/prelude.cf
===================================================================
--- src/libcfa/prelude.cf	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/prelude.cf	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -1,2 +1,3 @@
+# 2 "prelude.cf"  // needed for error messages from this file
 //                               -*- Mode: C -*- 
 // 
@@ -8,6 +9,6 @@
 // Created On       : Sat Nov 29 07:23:41 2014
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan  4 11:13:26 2016
-// Update Count     : 81
+// Last Modified On : Wed Mar  2 18:03:41 2016
+// Update Count     : 89
 //
 
@@ -63,21 +64,21 @@
 long double _Complex	?--( long double _Complex * ),		?--( volatile long double _Complex * );
 
-forall( type T ) T *			 ?++(		     T ** );
-forall( type T ) const T *		 ?++( const	     T ** );
-forall( type T ) volatile T *		 ?++(	    volatile T ** );
-forall( type T ) const volatile T *	 ?++( const volatile T ** );
-forall( type T ) T *			 ?--(		     T ** );
-forall( type T ) const T *		 ?--( const	     T ** );
-forall( type T ) volatile T *		 ?--(	    volatile T ** );
-forall( type T ) const volatile T *	 ?--( const volatile T ** );
-
-forall( type T ) lvalue T		 ?[?](		      T *,	    ptrdiff_t );
-forall( type T ) const lvalue T		 ?[?]( const	      T *,	    ptrdiff_t );
-forall( type T ) volatile lvalue T	 ?[?](       volatile T *,	    ptrdiff_t );
-forall( type T ) const volatile lvalue T ?[?]( const volatile T *,	    ptrdiff_t );
-forall( type T ) lvalue T		 ?[?](		ptrdiff_t,		  T * );
-forall( type T ) const lvalue T		 ?[?](		ptrdiff_t, const	  T * );
-forall( type T ) volatile lvalue T	 ?[?](		ptrdiff_t,	 volatile T * );
-forall( type T ) const volatile lvalue T ?[?](		ptrdiff_t, const volatile T * );
+forall( otype T ) T *			 ?++(		     T ** );
+forall( otype T ) const T *		 ?++( const	     T ** );
+forall( otype T ) volatile T *		 ?++(	    volatile T ** );
+forall( otype T ) const volatile T *	 ?++( const volatile T ** );
+forall( otype T ) T *			 ?--(		     T ** );
+forall( otype T ) const T *		 ?--( const	     T ** );
+forall( otype T ) volatile T *		 ?--(	    volatile T ** );
+forall( otype T ) const volatile T *	 ?--( const volatile T ** );
+
+forall( otype T ) lvalue T		 ?[?](		      T *,	    ptrdiff_t );
+forall( otype T ) const lvalue T	 ?[?]( const	      T *,	    ptrdiff_t );
+forall( otype T ) volatile lvalue T	 ?[?](       volatile T *,	    ptrdiff_t );
+forall( otype T ) const volatile lvalue T ?[?]( const volatile T *,	    ptrdiff_t );
+forall( otype T ) lvalue T		 ?[?](		ptrdiff_t,		  T * );
+forall( otype T ) const lvalue T	 ?[?](		ptrdiff_t, const	  T * );
+forall( otype T ) volatile lvalue T	 ?[?](		ptrdiff_t,	 volatile T * );
+forall( otype T ) const volatile lvalue T ?[?](		ptrdiff_t, const volatile T * );
 
 // ------------------------------------------------------------
@@ -101,17 +102,17 @@
 long double _Complex	++?( long double _Complex * ),		--?( long double _Complex * );
 
-forall( type T ) T *			 ++?(		     T ** );
-forall( type T ) const T *		 ++?( const	     T ** );
-forall( type T ) volatile T *		 ++?(	    volatile T ** );
-forall( type T ) const volatile T *	 ++?( const volatile T ** );
-forall( type T ) T *			 --?(		     T ** );
-forall( type T ) const T *		 --?( const	     T ** );
-forall( type T ) volatile T *		 --?(	    volatile T ** );
-forall( type T ) const volatile T *	 --?( const volatile T ** );
-
-forall( type T ) lvalue T		 *?(		     T * );
-forall( type T ) const lvalue T		 *?( const	     T * );
-forall( type T ) volatile lvalue T	 *?(       volatile  T * );
-forall( type T ) const volatile lvalue T *?( const volatile  T * );
+forall( otype T ) T *			 ++?(		     T ** );
+forall( otype T ) const T *		 ++?( const	     T ** );
+forall( otype T ) volatile T *		 ++?(	    volatile T ** );
+forall( otype T ) const volatile T *	 ++?( const volatile T ** );
+forall( otype T ) T *			 --?(		     T ** );
+forall( otype T ) const T *		 --?( const	     T ** );
+forall( otype T ) volatile T *		 --?(	    volatile T ** );
+forall( otype T ) const volatile T *	 --?( const volatile T ** );
+
+forall( otype T ) lvalue T		 *?(		     T * );
+forall( otype T ) const lvalue T		 *?( const	     T * );
+forall( otype T ) volatile lvalue T	 *?(       volatile  T * );
+forall( otype T ) const volatile lvalue T *?( const volatile  T * );
 forall( ftype FT ) lvalue FT		 *?( FT * );
 
@@ -183,17 +184,17 @@
 long double _Complex	?+?( long double _Complex, long double _Complex ),	?-?( long double _Complex, long double _Complex );
 
-forall( type T ) T *			?+?(		    T *,	  ptrdiff_t );
-forall( type T ) T *			?+?(	      ptrdiff_t,		T * );
-forall( type T ) const T *		?+?( const	    T *,	  ptrdiff_t );
-forall( type T ) const T *		?+?(	      ptrdiff_t, const		T * );
-forall( type T ) volatile T *		?+?(	   volatile T *,	  ptrdiff_t );
-forall( type T ) volatile T *		?+?(	      ptrdiff_t,       volatile T * );
-forall( type T ) const volatile T *	?+?( const volatile T *,	  ptrdiff_t );
-forall( type T ) const volatile T *	?+?(	      ptrdiff_t, const volatile T * );
-forall( type T ) T *			?-?(		    T *,	  ptrdiff_t );
-forall( type T ) const T *		?-?( const	    T *,	  ptrdiff_t );
-forall( type T ) volatile T *		?-?(	   volatile T *,	  ptrdiff_t );
-forall( type T ) const volatile T *	?-?( const volatile T *,	  ptrdiff_t );
-forall( type T ) ptrdiff_t		?-?( const volatile T *, const volatile T * );
+forall( otype T ) T *			?+?(		    T *,	  ptrdiff_t );
+forall( otype T ) T *			?+?(	      ptrdiff_t,		T * );
+forall( otype T ) const T *		?+?( const	    T *,	  ptrdiff_t );
+forall( otype T ) const T *		?+?(	      ptrdiff_t, const		T * );
+forall( otype T ) volatile T *		?+?(	   volatile T *,	  ptrdiff_t );
+forall( otype T ) volatile T *		?+?(	      ptrdiff_t,       volatile T * );
+forall( otype T ) const volatile T *	?+?( const volatile T *,	  ptrdiff_t );
+forall( otype T ) const volatile T *	?+?(	      ptrdiff_t, const volatile T * );
+forall( otype T ) T *			?-?(		    T *,	  ptrdiff_t );
+forall( otype T ) const T *		?-?( const	    T *,	  ptrdiff_t );
+forall( otype T ) volatile T *		?-?(	   volatile T *,	  ptrdiff_t );
+forall( otype T ) const volatile T *	?-?( const volatile T *,	  ptrdiff_t );
+forall( otype T ) ptrdiff_t		?-?( const volatile T *, const volatile T * );
 
 // ------------------------------------------------------------
@@ -431,20 +432,20 @@
 forall( ftype FT ) FT *			?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
 
-forall( type T ) T *			?+=?(		     T *	  *, ptrdiff_t );
-forall( type T ) T *			?+=?(		     T * volatile *, ptrdiff_t );
-forall( type T ) const T *		?+=?( const	     T *	  *, ptrdiff_t );
-forall( type T ) const T *		?+=?( const	     T * volatile *, ptrdiff_t );
-forall( type T ) volatile T *		?+=?(	    volatile T *	  *, ptrdiff_t );
-forall( type T ) volatile T *		?+=?(	    volatile T * volatile *, ptrdiff_t );
-forall( type T ) const volatile T *	?+=?( const volatile T *	  *, ptrdiff_t );
-forall( type T ) const volatile T *	?+=?( const volatile T * volatile *, ptrdiff_t );
-forall( type T ) T *			?-=?(		     T *	  *, ptrdiff_t );
-forall( type T ) T *			?-=?(		     T * volatile *, ptrdiff_t );
-forall( type T ) const T *		?-=?( const	     T *	  *, ptrdiff_t );
-forall( type T ) const T *		?-=?( const	     T * volatile *, ptrdiff_t );
-forall( type T ) volatile T *		?-=?(	    volatile T *	  *, ptrdiff_t );
-forall( type T ) volatile T *		?-=?(	    volatile T * volatile *, ptrdiff_t );
-forall( type T ) const volatile T *	?-=?( const volatile T *	  *, ptrdiff_t );
-forall( type T ) const volatile T *	?-=?( const volatile T * volatile *, ptrdiff_t );
+forall( otype T ) T *			?+=?(		     T *	  *, ptrdiff_t );
+forall( otype T ) T *			?+=?(		     T * volatile *, ptrdiff_t );
+forall( otype T ) const T *		?+=?( const	     T *	  *, ptrdiff_t );
+forall( otype T ) const T *		?+=?( const	     T * volatile *, ptrdiff_t );
+forall( otype T ) volatile T *		?+=?(	    volatile T *	  *, ptrdiff_t );
+forall( otype T ) volatile T *		?+=?(	    volatile T * volatile *, ptrdiff_t );
+forall( otype T ) const volatile T *	?+=?( const volatile T *	  *, ptrdiff_t );
+forall( otype T ) const volatile T *	?+=?( const volatile T * volatile *, ptrdiff_t );
+forall( otype T ) T *			?-=?(		     T *	  *, ptrdiff_t );
+forall( otype T ) T *			?-=?(		     T * volatile *, ptrdiff_t );
+forall( otype T ) const T *		?-=?( const	     T *	  *, ptrdiff_t );
+forall( otype T ) const T *		?-=?( const	     T * volatile *, ptrdiff_t );
+forall( otype T ) volatile T *		?-=?(	    volatile T *	  *, ptrdiff_t );
+forall( otype T ) volatile T *		?-=?(	    volatile T * volatile *, ptrdiff_t );
+forall( otype T ) const volatile T *	?-=?( const volatile T *	  *, ptrdiff_t );
+forall( otype T ) const volatile T *	?-=?( const volatile T * volatile *, ptrdiff_t );
 
 _Bool			?=?( _Bool *, _Bool ),					?=?( volatile _Bool *, _Bool );
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/stdlib	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 16:52:25 2016
-// Update Count     : 63
+// Last Modified On : Wed Mar  2 17:38:21 2016
+// Update Count     : 64
 //
 
@@ -20,18 +20,18 @@
 } // extern "C"
 
-forall( type T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
-forall( type T ) T * memset( T * ptr );					// remove when default value available
+forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr );					// remove when default value available
 
-forall( type T ) T * malloc( void );
-forall( type T ) T * malloc( char fill );
-forall( type T ) T * malloc( T * ptr, size_t size );
-forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill );
-forall( type T ) T * calloc( size_t size );
-forall( type T ) T * realloc( T * ptr, size_t size );
-forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( char fill );
+forall( otype T ) T * malloc( T * ptr, size_t size );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * calloc( size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
 
-forall( type T ) T * aligned_alloc( size_t alignment );
-forall( type T ) T * memalign( size_t alignment );		// deprecated
-forall( type T ) int posix_memalign( T ** ptr, size_t alignment );
+forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );		// deprecated
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
 
 //---------------------------------------
@@ -65,13 +65,13 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension );
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension );
 
 //---------------------------------------
 
-forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 );
 
@@ -107,11 +107,11 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 );
 
-forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 );
 
-forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 );
 
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/stdlib.c	(revision 40404257da8f22441f6123bdbff37bdb54e0e5f3)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 23 21:02:54 2016
-// Update Count     : 142
+// Last Modified On : Wed Mar  2 17:38:47 2016
+// Update Count     : 143
 //
 
@@ -27,22 +27,22 @@
 } // extern "C"
 
-forall( type T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
 	printf( "memset1\n" );
     return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
 } // memset
-forall( type T ) T * memset( T * ptr ) {				// remove when default value available
+forall( otype T ) T * memset( T * ptr ) {				// remove when default value available
 	printf( "memset2\n" );
     return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
 } // memset
 
-forall( type T ) T * malloc( void ) {
+forall( otype T ) T * malloc( void ) {
 	printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
-forall( type T ) T * malloc( size_t size ) {
+forall( otype T ) T * malloc( size_t size ) {
 	printf( "malloc2\n" );
     return (T *)(void *)malloc( size );
 } // malloc
-forall( type T ) T * malloc( char fill ) {
+forall( otype T ) T * malloc( char fill ) {
 	printf( "malloc3\n" );
 	T * ptr = (T *)malloc( sizeof(T) );
@@ -50,14 +50,14 @@
 } // malloc
 
-forall( type T ) T * calloc( size_t size ) {
+forall( otype T ) T * calloc( size_t size ) {
 	printf( "calloc\n" );
     return (T *)calloc( size, sizeof(T) );
 } // calloc
 
-forall( type T ) T * realloc( T * ptr, size_t size ) {
+forall( otype T ) T * realloc( T * ptr, size_t size ) {
 	printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
-forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
 	printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
@@ -67,24 +67,24 @@
 } // realloc
 
-forall( type T ) T * malloc( T * ptr, size_t size ) {
+forall( otype T ) T * malloc( T * ptr, size_t size ) {
 	printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
-forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
 	printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 
-forall( type T ) T * aligned_alloc( size_t alignment ) {
+forall( otype T ) T * aligned_alloc( size_t alignment ) {
 	printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 
-forall( type T ) T * memalign( size_t alignment ) {
+forall( otype T ) T * memalign( size_t alignment ) {
 	printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 
-forall( type T ) int posix_memalign( T ** ptr, size_t alignment ) {
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
 	printf( "posix_memalign\n" );
     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
@@ -212,5 +212,5 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension ) {
 	int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -218,5 +218,5 @@
 } // bsearch
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension ) {
 	int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -226,5 +226,5 @@
 //---------------------------------------
 
-forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
 
@@ -257,15 +257,15 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 ) {
 	return t1 < t2 ? t1 : t2;
 } // min
 
-forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 ) {
 	return t1 > t2 ? t1 : t2;
 } // max
 
-forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 ) {
 	T temp = *t1;
